Mundial

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: DialogoCrearEquipo.java,v 1.5 2006/12/01 22:29:13 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.awt.Dimension;
 
import java.awt.Toolkit;
 

 
import javax.swing.JDialog;
 
import javax.swing.JOptionPane;
 

 
/**
 
 * Es el diálogo para crear un nuevo equipo
 
 */
 
public class DialogoCrearEquipo extends JDialog
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es una referencia a la clase principal de la interfaz
 
     */
 
    private InterfazMundial principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de la Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el panel con los datos para crear el nuevo equipo
 
     */
 
    private PanelCrearEquipo panelDatos;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye el diálogo
 
     * @param ventana Es una referencia a la clase principal de la interfaz - ventana!=null
 
     */
 
    public DialogoCrearEquipo( InterfazMundial ventana )
 
    {
 
        super( ventana, true );
 
        principal = ventana;
 

 
        panelDatos = new PanelCrearEquipo( this );
 

 
        add( panelDatos, BorderLayout.CENTER );
 

 
        setTitle( "Crear Equipo" );
 
        setResizable( false );
 
        pack( );
 
        centrar( );
 

 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Centra la ventana en la pantalla
 
     */
 
    private void centrar( )
 
    {
 
        Dimension screen = Toolkit.getDefaultToolkit( ).getScreenSize( );
 
        int xEsquina = ( screen.width - getWidth( ) ) / 2;
 
        int yEsquina = ( screen.height - getHeight( ) ) / 2;
 
        setLocation( xEsquina, yEsquina );
 
    }
 

 
    /**
 
     * Crea el equipo y lo guarda
 
     */
 
    public void crearEquipo( )
 
    {
 
        boolean parametersOk = true;
 
        String pais = panelDatos.darPais( );
 
        String director = panelDatos.darDirector( );
 
        String imagen = panelDatos.darImagen( );
 

 
        if( ( pais.equals( "" ) || director.equals( "" ) ) || imagen.equals( "" ) )
 
        {
 
            parametersOk = false;
 
            JOptionPane.showMessageDialog( this, "Se deben ingresar todos los datos para crear el equipo", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
        if( parametersOk )
 
        {
 
            boolean ok = principal.crearEquipo( pais, director, imagen );
 
            if( ok )
 
                dispose( );
 
        }
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: DialogoCrearJugador.java,v 1.5 2006/12/01 22:29:13 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.awt.Dimension;
 
import java.awt.Toolkit;
 

 
import javax.swing.JDialog;
 
import javax.swing.JOptionPane;
 

 
/**
 
 * Es el diálogo para crear un nuevo jugador
 
 */
 
public class DialogoCrearJugador extends JDialog
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es una referencia a la clase principal de la interfaz
 
     */
 
    private InterfazMundial principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de la Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el panel con los datos para crear el nuevo jugador
 
     */
 
    private PanelCrearJugador panelDatos;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye el diálogo *
 
     * @param ventana Es una referencia a la clase principal de la interfaz
 
     */
 
    public DialogoCrearJugador( InterfazMundial ventana )
 
    {
 
        super( ventana, true );
 
        principal = ventana;
 

 
        panelDatos = new PanelCrearJugador( this );
 

 
        add( panelDatos, BorderLayout.CENTER );
 

 
        setTitle( "Crear Jugador" );
 
        pack( );
 
        centrar( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Centra el diálogo en la pantalla
 
     */
 
    private void centrar( )
 
    {
 
        Dimension screen = Toolkit.getDefaultToolkit( ).getScreenSize( );
 
        int xEsquina = ( screen.width - getWidth( ) ) / 2;
 
        int yEsquina = ( screen.height - getHeight( ) ) / 2;
 
        setLocation( xEsquina, yEsquina );
 
    }
 

 
    /**
 
     * Adiciona el jugador al mundial
 
     */
 
    public void crearJugador( )
 
    {
 
        boolean parametersOk = true;
 
        String nombre = null;
 
        int edad = 0;
 
        String posicion = null;
 
        double altura = 0;
 
        double peso = 0;
 
        double salario = 0;
 
        String imagen = null;
 

 
        nombre = panelDatos.darNombre( );
 

 
        if( nombre.equals( "" ) )
 
        {
 
            parametersOk = false;
 
            JOptionPane.showMessageDialog( this, "Debe ingresar el nombre del jugador", "error", JOptionPane.ERROR_MESSAGE );
 
        }
 
        else
 
        {
 
            try
 
            {
 
                edad = Integer.parseInt( panelDatos.darEdad( ) );
 
                if( edad < 0 )
 
                {
 
                    parametersOk = false;
 
                    JOptionPane.showMessageDialog( this, "La edad ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                }
 
                else
 
                {
 

 
                    posicion = panelDatos.darPosicion( );
 
                    if( posicion.equals( "" ) )
 
                    {
 
                        parametersOk = false;
 
                        JOptionPane.showMessageDialog( this, "La posición ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                    }
 
                    else
 
                    {
 
                        try
 
                        {
 
                            altura = Double.parseDouble( panelDatos.darAltura( ) );
 
                            if( altura < 0 )
 
                            {
 
                                parametersOk = false;
 
                                JOptionPane.showMessageDialog( this, "La altura ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                            }
 
                            else
 
                            {
 
                                try
 
                                {
 
                                    peso = Double.parseDouble( panelDatos.darPeso( ) );
 
                                    if( peso < 0 )
 
                                    {
 
                                        parametersOk = false;
 
                                        JOptionPane.showMessageDialog( this, "El peso ingresado no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                    }
 
                                    else
 
                                    {
 
                                        try
 
                                        {
 
                                            salario = Double.parseDouble( panelDatos.darSalario( ) );
 
                                            if( salario < 0 )
 
                                            {
 
                                                parametersOk = false;
 
                                                JOptionPane.showMessageDialog( this, "El salario ingresado no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                            }
 
                                            else
 
                                            {
 
                                                try
 
                                                {
 
                                                    imagen = panelDatos.darImagen( );
 
                                                    if( imagen.equals( "" ) )
 
                                                    {
 
                                                        parametersOk = false;
 
                                                        JOptionPane.showMessageDialog( this, "La ruta de la imagen ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                                    }
 
                                                }
 
                                                catch( NumberFormatException e )
 
                                                {
 
                                                    parametersOk = false;
 
                                                    JOptionPane.showMessageDialog( this, "La ruta de la imagen ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                                }
 
                                            }
 
                                        }
 
                                        catch( NumberFormatException e )
 
                                        {
 
                                            parametersOk = false;
 
                                            JOptionPane.showMessageDialog( this, "El salario ingresado no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                        }
 
                                    }
 
                                }
 
                                catch( NumberFormatException e )
 
                                {
 
                                    parametersOk = false;
 
                                    JOptionPane.showMessageDialog( this, "El peso ingresado no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                                }
 
                            }
 
                        }
 
                        catch( NumberFormatException e )
 
                        {
 
                            parametersOk = false;
 
                            JOptionPane.showMessageDialog( this, "La altura ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
                        }
 
                    }
 

 
                }
 
            }
 
            catch( NumberFormatException e )
 
            {
 
                parametersOk = false;
 
                JOptionPane.showMessageDialog( this, "La edad ingresada no es un valor válido", "error", JOptionPane.ERROR_MESSAGE );
 
            }
 
        }
 

 
        if( parametersOk )
 
        {
 
            boolean ok = principal.crearJugador( nombre, edad, posicion, altura, peso, salario, imagen );
 

 
            if( ok )
 
                dispose( );
 
        }
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: InterfazMundial.java,v 1.14 2006/12/01 23:20:25 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Toolkit;
 
import java.io.File;
 
import java.io.FileNotFoundException;
 
import java.io.IOException;
 
import java.text.DecimalFormat;
 
import java.text.NumberFormat;
 
import java.util.ArrayList;
 

 
import javax.swing.JFileChooser;
 
import javax.swing.JFrame;
 
import javax.swing.JOptionPane;
 

 
import uniandes.cupi2.mundial.mundo.ArchivoJugadoresException;
 
import uniandes.cupi2.mundial.mundo.ElementoExisteException;
 
import uniandes.cupi2.mundial.mundo.Equipo;
 
import uniandes.cupi2.mundial.mundo.Jugador;
 
import uniandes.cupi2.mundial.mundo.Mundial;
 
import uniandes.cupi2.mundial.mundo.PersistenciaException;
 

 
/**
 
 * Esta es la ventana principal de la aplicación.
 
 */
 
public class InterfazMundial extends JFrame
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * La ruta donde deben guardarse los reportes
 
     */
 
    private static final String RUTA_REPORTES = "./data/reportes";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Clase principal del mundo
 
     */
 
    private Mundial mundial;
 

 
    /**
 
     * Es una referencia al equipo del cual se están mostrando los datos
 
     */
 
    private Equipo equipoSeleccionado;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de la interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Panel con los equipos
 
     */
 
    private PanelEquipos panelEquipos;
 

 
    /**
 
     * Panel con los jugadores
 
     */
 
    private PanelJugadores panelJugadores;
 

 
    /**
 
     * Panel con los botones
 
     */
 
    private PanelBotones panelBotones;
 

 
    /**
 
     * Panel con una imagen decorativa
 
     */
 
    private PanelImagen panelImagen;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye la interfaz de la aplicación
 
     * @param m Es el mundial de fútbol que se va a mostrar - m!=null
 
     */
 
    public InterfazMundial( Mundial m )
 
    {
 

 
        // Crea la clase principal
 
        mundial = m;
 

 
        // Construye la forma
 
        setTitle( "Mundial de fútbol CUPI2" );
 
        setLayout( new GridBagLayout( ) );
 
        setSize( 560, 600 );
 
        setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
 
        setResizable(false);
 

 
        // Creación de los paneles aquí
 
        panelImagen = new PanelImagen( );
 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        add( panelImagen, gbc );
 

 
        panelEquipos = new PanelEquipos( this, mundial.darNombresEquipos( ) );
 
        gbc.gridy = 1;
 
        add( panelEquipos, gbc );
 

 
        panelJugadores = new PanelJugadores( this );
 
        gbc.gridy = 2;
 
        add( panelJugadores, gbc );
 

 
        ArrayList equipos = mundial.darNombresEquipos( );
 
        if( equipos.size( ) > 0 )
 
        {
 
            cambiarEquipoSeleccionado( ( ( String )equipos.get( 0 ) ) );
 
        }
 

 
        panelBotones = new PanelBotones( this );
 
        gbc.gridy = 3;
 
        add( panelBotones, gbc );
 
        centrar( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Centra la ventana en la pantalla
 
     */
 
    private void centrar( )
 
    {
 
        Dimension screen = Toolkit.getDefaultToolkit( ).getScreenSize( );
 
        int xEsquina = ( screen.width - getWidth( ) ) / 2;
 
        int yEsquina = ( screen.height - getHeight( ) ) / 2;
 
        setLocation( xEsquina, yEsquina );
 
    }
 

 
    /**
 
     * Cambia el equipo seleccionado en el panel de detalles del equipo
 
     * @param nombreEquipo El nombre del equipo a mostrar los detalles - nombreEquipo!=null
 
     */
 
    public void cambiarEquipoSeleccionado( String nombreEquipo )
 
    {
 
        equipoSeleccionado = mundial.darEquipo( nombreEquipo );
 
        panelEquipos.cambiarEquipo( equipoSeleccionado );
 
        panelJugadores.cambiarJugadores( equipoSeleccionado );
 
    }
 

 
    /**
 
     * Cambia el jugador seleccionado en el panel de detalles del equipoSeleccionado
 
     * @param nombreJugador El nombre del jugador - nombreJugador!=null
 
     */
 
    public void cambiarJugadorSeleccionado( String nombreJugador )
 
    {
 
        Jugador jugador = equipoSeleccionado.darJugador( nombreJugador );
 

 
        if( jugador != null )
 
        {
 
            panelJugadores.cambiarJugador( jugador );
 
        }
 

 
    }
 

 
    /**
 
     * Muestra el diálogo para agregar un nuevo equipoSeleccionado al mundial
 
     */
 
    public void mostrarDialogoAgregarEquipo( )
 
    {
 
        DialogoCrearEquipo dialogo = new DialogoCrearEquipo( this );
 
        dialogo.setVisible( true );
 
    }
 

 
    /**
 
     * Muestra el diálogo para agregar un nuevo jugador al equipoSeleccionado en el panel de jugadores
 
     */
 
    public void mostrarDialogoAgregarJugador( )
 
    {
 
        DialogoCrearJugador dialogo = new DialogoCrearJugador( this );
 
        dialogo.setVisible( true );
 

 
    }
 

 
    /**
 
     * Crea un nuevo equipo en el mundial y actualiza el panel con la lista de equipos <br>
 
     * <b>pre: <b>No debe haber otro equipo representando al mismo país en el mundial
 
     * @param pais Es el país del equipoSeleccionado - pais != null
 
     * @param director Es el nombre del director técnico del equipoSeleccionado - director != null
 
     * @param imagen Es la ruta de la imagen con la bandera del equipoSeleccionado - imagen != null
 
     * @return Retorna true si el equipo se pudo agregar. Esto sirve para saber si se debe cerrar el diálogo.
 
     */
 
    public boolean crearEquipo( String pais, String director, String imagen )
 
    {
 
        boolean ok = false;
 
        try
 
        {
 
            mundial.agregarEquipo( pais, director, imagen );
 
            panelEquipos.refrescarEquipos( mundial.darNombresEquipos( ) );
 
            ok = true;
 
        }
 
        catch( ElementoExisteException e )
 
        {
 
            JOptionPane.showMessageDialog( this, e.getMessage( ) );
 
        }
 

 
        return ok;
 
    }
 

 
    /**
 
     * Crea un nuevo jugador en el equipo que se muestra en los detalles de equipo del mundial <br>
 
     * <b>pre: <b>No debe haber otro jugador con el mismo nombre en el equipo
 
     * @param nombre El nombre del jugador - nombre != null
 
     * @param edad La edad del jugador - edad > 0
 
     * @param posicion La posición en la que juega el jugador - posicion != null
 
     * @param altura Es la altura del jugador en metros - altura > 0
 
     * @param peso Es el peso del jugador en kilogramos - peso > 0
 
     * @param salario Es el salario del jugador - salario > 0
 
     * @param imagen Es la ruta a la imagen con la foto del jugador - imagen != null
 
     * @return Retorna true si el jugador se pudo agregar. Esto sirve para saber si se debe cerrar el diálogo.
 
     */
 
    public boolean crearJugador( String nombre, int edad, String posicion, double altura, double peso, double salario, String imagen )
 
    {
 
        boolean ok = false;
 

 
        if( equipoSeleccionado != null )
 
        {
 
            try
 
            {
 
                mundial.agregarJugadorAEquipo( equipoSeleccionado.darPais( ), nombre, edad, posicion, altura, peso, salario, imagen );
 
                equipoSeleccionado = mundial.darEquipo( equipoSeleccionado.darPais( ) );
 
                panelJugadores.cambiarJugadores( equipoSeleccionado );
 
                ok = true;
 
            }
 
            catch( ElementoExisteException e )
 
            {
 
                JOptionPane.showMessageDialog( this, e.getMessage( ) );
 
            }
 
        }
 

 
        return ok;
 
    }
 

 
    /**
 
     * Calcula el valor de la nómina del equipo seleccionado
 
     */
 
    public void calcularValorNomina( )
 
    {
 

 
        try
 
        {
 
            String archivoReporte = mundial.calcularValorNomina( equipoSeleccionado.darPais( ), RUTA_REPORTES );
 
            JOptionPane.showMessageDialog( this, "El reporte se guardó en el archivo: " + archivoReporte, "Reporte Guardado", JOptionPane.INFORMATION_MESSAGE );
 
        }
 
        catch( IOException e )
 
        {
 
            JOptionPane.showMessageDialog( this, "Se presentó un problema guardando el archivo con el reporte:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 

 
    }
 

 
    /**
 
     * Este método se encarga de modificar la información de los jugadores a partir de un archivo
 
     */
 
    public void modificarInformacionJugadores( )
 
    {
 
        JFileChooser fc = new JFileChooser( "./data" );
 
        fc.setDialogTitle( "Modificar información de jugadores" );
 
        int resultado = fc.showOpenDialog( this );
 
        if( resultado == JFileChooser.APPROVE_OPTION )
 
        {
 
            File archivo = fc.getSelectedFile( );
 
            if( archivo != null )
 
            {
 
                try
 
                {
 
                    mundial.modificarInformacionJugadores( archivo );
 
                    JOptionPane.showMessageDialog( this, "La información de los jugadores fue modificada", "Modificar Información Jugadores", JOptionPane.INFORMATION_MESSAGE );
 
                }
 
                catch( FileNotFoundException e )
 
                {
 
                    JOptionPane.showMessageDialog( this, "Se presentó un problema leyendo el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );
 
                }
 
                catch( IOException e )
 
                {
 
                    JOptionPane.showMessageDialog( this, "Se presentó un problema leyendo el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );
 
                }
 
                catch( ArchivoJugadoresException e )
 
                {
 
                    JOptionPane.showMessageDialog( this, "Se presentó un problema debido al formato del archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );
 
                }
 
            }
 
        }
 

 
        panelEquipos.refrescarEquipos( mundial.darNombresEquipos( ) );
 
    }
 

 
    /**
 
     * Formatea un valor numérico para presentar en la interfaz <br>
 
     * @param valor El valor numérico a ser formateado
 
     * @return Cadena con el valor formateado con puntos y signos.
 
     */
 
    public String formatearValor( double valor )
 
    {
 
        DecimalFormat df = ( DecimalFormat )NumberFormat.getInstance( );
 
        df.applyPattern( "$ ###,###.##" );
 
        df.setMinimumFractionDigits( 2 );
 
        return df.format( valor );
 
    }
 

 
    /**
 
     * Este método se encarga de salvar la información del mundial, justo antes de cerrar la aplicación
 
     */
 
    public void dispose( )
 
    {
 
        try
 
        {
 
            mundial.salvarMundial( );
 
            super.dispose( );
 
        }
 
        catch( Exception e )
 
        {
 
            setVisible( true );
 
            int respuesta = JOptionPane.showConfirmDialog( this, "Problemas salvando la información del mundial:\n" + e.getMessage( ) + "\nࠑuiere cerrar el programa sin salvar?", "Error", JOptionPane.YES_NO_OPTION );
 
            if( respuesta == JOptionPane.YES_OPTION )
 
            {
 
                super.dispose( );
 
            }
 
        }
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Puntos de Extensión
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Método para la extensión 1
 
     */
 
    public void reqFuncOpcion1( )
 
    {
 
        String resultado = mundial.metodo1( );
 
        JOptionPane.showMessageDialog( this, resultado, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

 
    /**
 
     * Método para la extensión 2
 
     */
 
    public void reqFuncOpcion2( )
 
    {
 
        String resultado = mundial.metodo2( );
 
        JOptionPane.showMessageDialog( this, resultado, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Main
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Este método ejecuta la aplicación, creando una nueva interfaz
 
     * @param args Argumentos para la ejecución de la aplicación. No deben usarse
 
     */
 
    public static void main( String[] args )
 
    {
 
        Mundial mundial = null;
 

 
        try
 
        {
 
            mundial = new Mundial( "./data/mundial.equipos" );
 
        }
 
        catch( PersistenciaException e )
 
        {
 
            e.printStackTrace( );
 
            System.exit( 1 );
 
        }
 

 
        InterfazMundial id = new InterfazMundial( mundial );
 
        id.setVisible( true );
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelBotones.java,v 1.4 2006/12/01 21:18:19 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

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

 
import javax.swing.JButton;
 
import javax.swing.JPanel;
 
import javax.swing.border.CompoundBorder;
 
import javax.swing.border.EmptyBorder;
 
import javax.swing.border.TitledBorder;
 

 
/**
 
 * Es el panel donde se encuentran los botones principales de la aplicación
 
 */
 
public class PanelBotones extends JPanel implements ActionListener
 
{
 

 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Comando para agregar un equipo
 
     */
 
    private static final String AGREGAR_EQUIPO = "AgregarEquipo";
 

 
    /**
 
     * Comando para agregar un jugador
 
     */
 
    private static final String AGREGAR_JUGADOR = "AgregarJugador";
 

 
    /**
 
     * Comando para calcular el valor de la nómina de un equipo
 
     */
 
    private static final String CALCULAR_NOMINA = "CalcularNomina";
 

 
    /**
 
     * Comando para cargar los equipos y jugadores del mundial
 
     */
 
    private static final String MODIFICAR_INFORMACION_JUGADORES = "ModificarInformacionJugadores";
 

 
    /**
 
     * Comando Opción 1
 
     */
 
    private static final String OPCION_1 = "OPCION_1";
 

 
    /**
 
     * Comando Opción 2
 
     */
 
    private static final String OPCION_2 = "OPCION_2";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Ventana principal de la aplicación
 
     */
 
    private InterfazMundial principal;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el botón para agregar un equipo
 
     */
 
    private JButton botonAgregarEquipo;
 

 
    /**
 
     * Es el botón para agregar un jugador
 
     */
 
    private JButton botonAgregarJugador;
 

 
    /**
 
     * Es el botón para calcular la nómina de un equipo
 
     */
 
    private JButton botonCalcularNomina;
 

 
    /**
 
     * Es el botón para modificar la información de los jugadores
 
     */
 
    private JButton botonModificarInformacionJugadores;
 

 
    /**
 
     * Botón Opción 1
 
     */
 
    private JButton botonOpcion1;
 

 
    /**
 
     * Botón Opción 2
 
     */
 
    private JButton botonOpcion2;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constructor del panel
 
     * @param ventana Ventana principal - ventana!=null
 
     */
 
    public PanelBotones( InterfazMundial ventana )
 
    {
 
        principal = ventana;
 
        setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Opciones" ) ) );
 
        setLayout( new GridLayout( 2, 3, 3, 3 ) );
 

 
        // Botón agregar equipos
 
        botonAgregarEquipo = new JButton( "Agregar Equipo" );
 
        botonAgregarEquipo.setActionCommand( AGREGAR_EQUIPO );
 
        botonAgregarEquipo.addActionListener( this );
 
        add( botonAgregarEquipo );
 

 
        // Botón agregar jugador
 
        botonAgregarJugador = new JButton( "Agregar Jugador" );
 
        botonAgregarJugador.setActionCommand( AGREGAR_JUGADOR );
 
        botonAgregarJugador.addActionListener( this );
 
        add( botonAgregarJugador );
 

 
        // Botón calcular nómina
 
        botonCalcularNomina = new JButton( "Calcular Nómina" );
 
        botonCalcularNomina.setActionCommand( CALCULAR_NOMINA );
 
        botonCalcularNomina.addActionListener( this );
 
        add( botonCalcularNomina );
 

 
        // Botón modificar información jugadores
 
        botonModificarInformacionJugadores = new JButton( "Modificar Jugadores" );
 
        botonModificarInformacionJugadores.setActionCommand( MODIFICAR_INFORMACION_JUGADORES );
 
        botonModificarInformacionJugadores.addActionListener( this );
 
        add( botonModificarInformacionJugadores );
 

 
        // Botón opción 1
 
        botonOpcion1 = new JButton( "Opción 1" );
 
        botonOpcion1.setActionCommand( OPCION_1 );
 
        botonOpcion1.addActionListener( this );
 
        add( botonOpcion1 );
 

 
        // Botón opción 2
 
        botonOpcion2 = new JButton( "Opción 2" );
 
        botonOpcion2.setActionCommand( OPCION_2 );
 
        botonOpcion2.addActionListener( this );
 
        add( botonOpcion2 );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Manejo de los eventos de los botones
 
     * @param evento Acción que generó el evento - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( AGREGAR_EQUIPO.equals( comando ) )
 
        {
 
            principal.mostrarDialogoAgregarEquipo( );
 
        }
 
        else if( AGREGAR_JUGADOR.equals( comando ) )
 
        {
 
            principal.mostrarDialogoAgregarJugador( );
 
        }
 
        else if( CALCULAR_NOMINA.equals( comando ) )
 
        {
 
            principal.calcularValorNomina( );
 
        }
 
        else if( MODIFICAR_INFORMACION_JUGADORES.equals( comando ) )
 
        {
 
            principal.modificarInformacionJugadores( );
 
        }
 
        else if( OPCION_1.equals( comando ) )
 
        {
 
            principal.reqFuncOpcion1( );
 
        }
 
        else if( OPCION_2.equals( comando ) )
 
        {
 
            principal.reqFuncOpcion2( );
 
        }
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelCrearEquipo.java,v 1.7 2007/04/12 13:38:06 carl-veg Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.GridLayout;
 
import java.awt.Insets;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.io.File;
 

 
import javax.swing.JButton;
 
import javax.swing.JFileChooser;
 
import javax.swing.JLabel;
 
import javax.swing.JPanel;
 
import javax.swing.JTextField;
 
import javax.swing.border.EmptyBorder;
 

 
/**
 
 * Es el panel donde se ingresan los datos para un nuevo equipo
 
 */
 
public class PanelCrearEquipo extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * El comando para el botón Crear
 
     */
 
    private static final String CREAR_EQUIPO = "CrearEquipo";
 

 
    /**
 
     * El comando para el botón Cancelar
 
     */
 
    private static final String CANCELAR = "Cancelar";
 

 
    /**
 
     * El comando para el botón Explorar
 
     */
 
    private static final String EXPLORAR = "Explorar";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es una referencia al diálogo al que pertenece este panel
 
     */
 
    private DialogoCrearEquipo dialogo;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de la Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es la etiqueta "País: "
 
     */
 
    private JLabel etiquetaPais;
 

 
    /**
 
     * Es el campo de texto para ingresar el país del equipo
 
     */
 
    private JTextField txtPais;
 

 
    /**
 
     * Es la etiqueta "Director: "
 
     */
 
    private JLabel etiquetaDirector;
 

 
    /**
 
     * Es el campo de texto para ingresar el director técnico del equipo
 
     */
 
    private JTextField txtDirector;
 

 
    /**
 
     * Es la etiqueta "Imagen"
 
     */
 
    private JLabel etiquetaImagen;
 

 
    /**
 
     * Es el campo de texto para ingresar la ruta con la imagen del equipo
 
     */
 
    private JTextField txtImagen;
 

 
    /**
 
     * Es el botón usado para buscar la imagen
 
     */
 
    private JButton botonExplorar;
 

 
    /**
 
     * Es el botón que sirve para agregar un nuevo equipo
 
     */
 
    private JButton botonAgregarEquipo;
 

 
    /**
 
     * Es el botón que sirve para cerrar el diálogo sin guardar los cambios
 
     */
 
    private JButton botonCancelar;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye el panel creando las etiquetas y los campos de texto necesarios para crear un nuevo equipo
 
     * @param d Dialogo con el cual se crea un equipo
 
     */
 
    public PanelCrearEquipo( DialogoCrearEquipo d )
 
    {
 
        dialogo = d;
 
        setLayout( new GridBagLayout( ) );
 

 
        etiquetaPais = new JLabel( "País: " );
 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        gbc.insets = new Insets( 3, 3, 3, 3 );
 
        add( etiquetaPais, gbc );
 

 
        txtPais = new JTextField( );
 
        txtPais.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 

 
        add( txtPais, gbc );
 

 
        etiquetaDirector = new JLabel( "Director Técnico: " );
 
        gbc.gridx = 0;
 
        gbc.gridy = 1;
 
        add( etiquetaDirector, gbc );
 

 
        txtDirector = new JTextField( );
 
        txtDirector.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtDirector, gbc );
 

 
        etiquetaImagen = new JLabel( "Imagen: " );
 
        gbc.gridx = 0;
 
        gbc.gridy = 2;
 
        add( etiquetaImagen, gbc );
 

 
        JPanel panelImagen = new JPanel( );
 
        panelImagen.setLayout( new GridLayout( 1, 2, 3, 3 ) );
 

 
        txtImagen = new JTextField( );
 
        panelImagen.add( txtImagen );
 

 
        botonExplorar = new JButton( "Explorar" );
 
        botonExplorar.setActionCommand( EXPLORAR );
 
        botonExplorar.addActionListener( this );
 
        panelImagen.add( botonExplorar );
 

 
        gbc.gridx = 1;
 
        add( panelImagen, gbc );
 

 
        JPanel panelBotones = new JPanel( );
 
        panelBotones.setLayout( new GridBagLayout( ) );
 

 
        botonAgregarEquipo = new JButton( "Crear" );
 
        botonAgregarEquipo.setActionCommand( CREAR_EQUIPO );
 
        botonAgregarEquipo.addActionListener( this );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        panelBotones.add( botonAgregarEquipo, gbc );
 

 
        botonCancelar = new JButton( "Cancelar" );
 
        botonCancelar.setActionCommand( CANCELAR );
 
        botonCancelar.addActionListener( this );
 
        gbc.gridx = 1;
 
        panelBotones.add( botonCancelar, gbc );
 

 
        gbc.gridx = 0;
 
        gbc.gridy = 3;
 
        gbc.gridwidth = 2;
 
        add( panelBotones, gbc );
 

 
        setBorder( new EmptyBorder( 5, 5, 5, 5 ) );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Da el valor del campo de texto con el país del equipo
 
     * @return Se retornó el nombre del país ingresado por el usuario
 
     */
 
    public String darPais( )
 
    {
 
        return txtPais.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con el director técnico del equipo
 
     * @return Se retornó el nombre del director ingresado por el usuario
 
     */
 
    public String darDirector( )
 
    {
 
        return txtDirector.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con la ruta de la imagen de la bandera del equipo
 
     * @return Se retornó la ruta de la imagen ingresada por el usuario
 
     */
 
    public String darImagen( )
 
    {
 
        return txtImagen.getText( );
 
    }
 

 
    /**
 
     * Ejecuta una acción cuando se hace click sobre un botón
 
     * @param evento el evento del click sobre un botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( EXPLORAR.equals( comando ) )
 
        {
 
            JFileChooser fc = new JFileChooser( "./data/imagenes" );
 
            fc.setDialogTitle( "Imagen de la bandera del equipo" );
 
            int resultado = fc.showOpenDialog( this );
 
            if( resultado == JFileChooser.APPROVE_OPTION )
 
            {
 
                File archivo = fc.getSelectedFile( );
 
                txtImagen.setText( "data/imagenes/" + archivo.getParentFile( ).getName( ) + "/" + archivo.getName( ) );
 
            }
 
        }
 
        else if( CREAR_EQUIPO.equals( comando ) )
 
        {
 
            dialogo.crearEquipo( );
 
        }
 
        else if( CANCELAR.equals( comando ) )
 
        {
 
            dialogo.dispose( );
 
        }
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelCrearJugador.java,v 1.9 2007/04/12 13:38:06 carl-veg Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.GridLayout;
 
import java.awt.Insets;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.io.File;
 

 
import javax.swing.JButton;
 
import javax.swing.JFileChooser;
 
import javax.swing.JLabel;
 
import javax.swing.JOptionPane;
 
import javax.swing.JPanel;
 
import javax.swing.JTextField;
 
import javax.swing.border.EmptyBorder;
 

 
/**
 
 * Es el panel donde se ingresan los datos para un nuevo jugador
 
 */
 
public class PanelCrearJugador extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * El comando para el botón Explorar
 
     */
 
    private static final String EXPLORAR = "Explorar";
 

 
    /**
 
     * El comando para el botón Crear
 
     */
 
    private static final String CREAR_JUGADOR = "CrearJugador";
 

 
    /**
 
     * El comando para el botón Cancelar
 
     */
 
    private static final String CANCELAR = "Cancelar";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es una referencia al dialogo al que pertenece este panel
 
     */
 
    private DialogoCrearJugador dialogo;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de la Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es la etiqueta "Imagen: "
 
     */
 
    private JLabel etiquetaImagen;
 

 
    /**
 
     * Es el campo de texto para ingresar la ruta de la imagen con la foto del jugador
 
     */
 
    private JTextField txtImagen;
 

 
    /**
 
     * Es la etiqueta "Nombre: "
 
     */
 
    private JLabel etiquetaNombre;
 

 
    /**
 
     * Es el campo de texto para ingresar el nombre del jugador
 
     */
 
    private JTextField txtNombre;
 

 
    /**
 
     * Es la etiqueta "Edad: "
 
     */
 
    private JLabel etiquetaEdad;
 

 
    /**
 
     * Es el campo de texto para ingresar la edad del jugador
 
     */
 
    private JTextField txtEdad;
 

 
    /**
 
     * Es la etiqueta "Posición: "
 
     */
 
    private JLabel etiquetaPosicion;
 

 
    /**
 
     * Es el campo de texto para ingresar la posición en la que juega el jugador
 
     */
 
    private JTextField txtPosicion;
 

 
    /**
 
     * Es la etiqueta "Altura: "
 
     */
 
    private JLabel etiquetaAltura;
 

 
    /**
 
     * Es el campo de texto para ingresar la altura del jugador
 
     */
 
    private JTextField txtAltura;
 

 
    /**
 
     * Es la etiqueta "Peso: "
 
     */
 
    private JLabel etiquetaPeso;
 

 
    /**
 
     * Es el campo de texto para ingresar el peso del jugador
 
     */
 
    private JTextField txtPeso;
 

 
    /**
 
     * Es la etiqueta "Salario: "
 
     */
 
    private JLabel etiquetaSalario;
 

 
    /**
 
     * Es el campo de texto para ingresar el salario del jugador
 
     */
 
    private JTextField txtSalario;
 

 
    /**
 
     * Es el botón usado para buscar la imagen
 
     */
 
    private JButton botonExplorar;
 

 
    /**
 
     * Es el botón que sirve para agregar un nuevo jugador
 
     */
 
    private JButton botonAgregarJugador;
 

 
    /**
 
     * Es el botón que sirve para cerrar el diálogo sin guardar los cambios
 
     */
 
    private JButton botonCancelar;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye el panel creando las etiquetas y los campos de texto necesarios para crear un nuevo jugador
 
     * @param d Dialogo con el cual se crea un jugador
 
     */
 
    public PanelCrearJugador( DialogoCrearJugador d )
 
    {
 
        dialogo = d;
 

 
        setLayout( new GridBagLayout( ) );
 

 
        etiquetaNombre = new JLabel( "Nombre: " );
 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        gbc.insets = new Insets( 3, 3, 3, 3 );
 
        add( etiquetaNombre, 0 );
 

 
        txtNombre = new JTextField( );
 
        txtNombre.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtNombre, gbc );
 

 
        etiquetaEdad = new JLabel( "Edad:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 1;
 
        add( etiquetaEdad, gbc );
 

 
        txtEdad = new JTextField( );
 
        txtEdad.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtEdad, gbc );
 

 
        etiquetaPosicion = new JLabel( "Posición:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 2;
 
        add( etiquetaPosicion, gbc );
 

 
        txtPosicion = new JTextField( );
 
        txtPosicion.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtPosicion, gbc );
 

 
        etiquetaAltura = new JLabel( "Altura:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 3;
 
        add( etiquetaAltura, gbc );
 

 
        txtAltura = new JTextField( );
 
        txtAltura.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtAltura, gbc );
 

 
        etiquetaPeso = new JLabel( "Peso:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 4;
 
        add( etiquetaPeso, gbc );
 

 
        txtPeso = new JTextField( );
 
        txtPeso.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtPeso, gbc );
 

 
        etiquetaSalario = new JLabel( "Salario:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 5;
 
        add( etiquetaSalario, gbc );
 

 
        txtSalario = new JTextField( );
 
        txtSalario.setPreferredSize( new Dimension( 80, 25 ) );
 
        gbc.gridx = 1;
 
        add( txtSalario, gbc );
 

 
        etiquetaImagen = new JLabel( "Imagen:" );
 
        gbc.gridx = 0;
 
        gbc.gridy = 6;
 
        add( etiquetaImagen, gbc );
 

 
        JPanel panelImagen = new JPanel( );
 
        panelImagen.setLayout( new GridLayout( 1, 2, 3, 3 ) );
 
        txtImagen = new JTextField( );
 
        panelImagen.add( txtImagen );
 

 
        botonExplorar = new JButton( "Explorar" );
 
        botonExplorar.setActionCommand( EXPLORAR );
 
        botonExplorar.addActionListener( this );
 
        panelImagen.add( botonExplorar );
 

 
        gbc.gridx = 1;
 
        add( panelImagen, gbc );
 

 
        JPanel panelBotones = new JPanel( );
 
        panelBotones.setLayout( new GridBagLayout( ) );
 

 
        botonAgregarJugador = new JButton( "Crear" );
 
        botonAgregarJugador.setActionCommand( CREAR_JUGADOR );
 
        botonAgregarJugador.addActionListener( this );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        panelBotones.add( botonAgregarJugador, gbc );
 

 
        botonCancelar = new JButton( "Cancelar" );
 
        botonCancelar.setActionCommand( CANCELAR );
 
        botonCancelar.addActionListener( this );
 
        gbc.gridx = 1;
 
        panelBotones.add( botonCancelar, gbc );
 

 
        gbc.gridx = 0;
 
        gbc.gridy = 7;
 
        gbc.gridwidth = 2;
 
        add( panelBotones, gbc );
 

 
        setBorder( new EmptyBorder( 5, 5, 5, 5 ) );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Da el valor del campo de texto con el nombre del jugador
 
     * @return Se retornó el nombre del jugador ingresado por el usuario
 
     */
 
    public String darNombre( )
 
    {
 
        return txtNombre.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con la edad del jugador
 
     * @return Se retornó la edad del jugador ingresada por el usuario
 
     */
 
    public String darEdad( )
 
    {
 
        return txtEdad.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con la posición del jugador
 
     * @return Se retornó la posición del jugador ingresado por el usuario
 
     */
 
    public String darPosicion( )
 
    {
 
        return txtPosicion.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con la altura del jugador
 
     * @return Se retornó la altura del jugador ingresado por el usuario
 
     */
 
    public String darAltura( )
 
    {
 
        return txtAltura.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con el peso del jugador
 
     * @return Se retornó el peso del jugador ingresado por el usuario
 
     */
 
    public String darPeso( )
 
    {
 
        return txtPeso.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con el salario del jugador
 
     * @return Se retornó el salario del jugador ingresado por el usuario
 
     */
 
    public String darSalario( )
 
    {
 
        return txtSalario.getText( );
 
    }
 

 
    /**
 
     * Da el valor del campo de texto con la ruta de la imagen con la foto del jugador
 
     * @return Se retornó el nombre de la imagen ingresada por el usuario
 
     */
 
    public String darImagen( )
 
    {
 
        return txtImagen.getText( );
 
    }
 

 
    /**
 
     * Ejecuta una acción cuando se hace click sobre un botón
 
     * @param evento el evento del click sobre un botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( EXPLORAR.equals( comando ) )
 
        {
 
            JFileChooser fc = new JFileChooser( "./data/imagenes" );
 
            fc.setDialogTitle( "Imagen del jugador" );
 
            int resultado = fc.showOpenDialog( this );
 

 
            if( resultado == JFileChooser.APPROVE_OPTION )
 
            {
 
                File archivo = fc.getSelectedFile( );
 
                String strArchivo = archivo.getAbsolutePath( );
 
                String strCarpetaImagenes = new File( "data/imagenes" ).getAbsolutePath( );
 

 
                if( strArchivo.startsWith( strCarpetaImagenes ) )
 
                {
 
                    txtImagen.setText( "data/imagenes/" + archivo.getParentFile( ).getName( ) + "/" + archivo.getName( ) );
 
                }
 
                else
 
                {
 
                    JOptionPane.showMessageDialog( this, "La imagen debe estar en la carpeta " + strCarpetaImagenes );
 
                }
 
            }
 
        }
 
        else if( CREAR_JUGADOR.equals( comando ) )
 
        {
 
            dialogo.crearJugador( );
 
        }
 
        else if( CANCELAR.equals( comando ) )
 
        {
 
            dialogo.dispose( );
 
        }
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelEquipos.java,v 1.7 2006/12/01 23:11:10 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Image;
 
import java.awt.Insets;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.awt.image.BufferedImage;
 
import java.io.File;
 
import java.io.IOException;
 
import java.util.ArrayList;
 

 
import javax.imageio.ImageIO;
 
import javax.swing.ImageIcon;
 
import javax.swing.JComboBox;
 
import javax.swing.JLabel;
 
import javax.swing.JOptionPane;
 
import javax.swing.JPanel;
 
import javax.swing.JTextField;
 
import javax.swing.border.CompoundBorder;
 
import javax.swing.border.EmptyBorder;
 
import javax.swing.border.TitledBorder;
 

 
import uniandes.cupi2.mundial.mundo.Equipo;
 

 
/**
 
 * Panel en el que se muestran los equipos
 
 */
 
public class PanelEquipos extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Esta constante indica la altura que debe tener la imagen de un individuo
 
     */
 
    private static final int ALTURA = 100;
 

 
    /**
 
     * Esta constante indica el ancho que debe tener la imagen de un individuo
 
     */
 
    private static final int ANCHO = 175;
 

 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Comando para cambiar los equipos
 
     */
 
    private static final String CAMBIAR_EQUIPO = "CambiarEquipo";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Ventana principal de la aplicación
 
     */
 
    private InterfazMundial principal;
 

 
    /**
 
     * Referencia al equipo que se está mostrando actualmente
 
     */
 
    private Equipo equipoActual;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el comboBox con la lista de equipos
 
     */
 
    private JComboBox comboEquipos;
 

 
    /**
 
     * Etiqueta bandera
 
     */
 
    private JLabel etiquetaBandera;
 

 
    /**
 
     * Etiqueta director técnico
 
     */
 
    private JLabel etiquetaDirector;
 

 
    /**
 
     * Etiqueta del equipo
 
     */
 
    private JLabel etiquetaEquipo;
 

 
    private JTextField txtDirector;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constructor del panel con los equipos del mundial
 
     * @param ventana Ventana principal - ventana!=null
 
     * @param equipos Una lista con los nombres de los países de los equipos del mundial - equipos!=null
 
     */
 

 
    public PanelEquipos( InterfazMundial ventana, ArrayList equipos )
 
    {
 
        principal = ventana;
 
        setLayout( new GridBagLayout( ) );
 
        setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Equipos" ) ) );
 

 
        JPanel panelAuxiliar = new JPanel( );
 
        panelAuxiliar.setLayout( new GridBagLayout( ) );
 
        comboEquipos = new JComboBox( equipos.toArray( ) );
 
        comboEquipos.setEditable( false );
 
        comboEquipos.addActionListener( this );
 
        comboEquipos.setActionCommand( CAMBIAR_EQUIPO );
 

 
        etiquetaEquipo = new JLabel( "Equipo" );
 

 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        gbc.insets = new Insets( 3, 3, 3, 3 );
 
        add( etiquetaEquipo, gbc );
 
        gbc.gridx = 1;
 
        panelAuxiliar.add( comboEquipos, gbc );
 

 
        etiquetaDirector = new JLabel( "Director Técnico" );
 
        panelAuxiliar.add( etiquetaDirector, gbc );
 
        gbc.gridx = 0;
 
        gbc.gridy = 1;
 
        panelAuxiliar.add( etiquetaDirector, gbc );
 
        txtDirector = new JTextField( "" );
 
        txtDirector.setEditable( false );
 
        txtDirector.setPreferredSize( new Dimension( 160, 20 ) );
 
        gbc.gridx = 1;
 
        panelAuxiliar.add( txtDirector, gbc );
 

 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.insets = new Insets( 24, 3, 3, 30 );
 
        add( panelAuxiliar, gbc );
 

 
        etiquetaBandera = new JLabel( "" );
 
        etiquetaBandera.setMaximumSize( new Dimension( ANCHO, ALTURA ) );
 
        etiquetaBandera.setMinimumSize( new Dimension( ANCHO, ALTURA ) );
 
        gbc.gridx = 1;
 
        gbc.gridy = 0;
 
        gbc.gridheight = 2;
 
        gbc.insets = new Insets( 3, 3, 3, 3 );
 
        add( etiquetaBandera, gbc );
 

 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Actualiza la información en el panel con la lista de equipos
 
     * @param equipos Lista de equipos del mundial - equipos!=null
 
     */
 
    public void cargarEquipos( ArrayList equipos )
 
    {
 
        comboEquipos.removeAllItems( );
 

 
        for( int i = 0; i < equipos.size( ); i++ )
 
        {
 
            comboEquipos.addItem( equipos.get( i ) );
 
        }
 
    }
 

 
    /**
 
     * Cambia el equipo actual que se muestra en el panel
 
     * @param equipo El nuevo equipo a mostrar en el panel - evento!=nulll
 
     */
 
    public void cambiarEquipo( Equipo equipo )
 
    {
 
        equipoActual = equipo;
 
        if( equipoActual != null )
 
        {
 
            BufferedImage imagen;
 
            try
 
            {
 
                imagen = ImageIO.read( new File( equipoActual.darImagen( ) ) );
 
                Image laImagen = imagen.getScaledInstance( ( int ) ( ANCHO ), ( int ) ( ALTURA ), Image.SCALE_AREA_AVERAGING );
 
                etiquetaBandera.setIcon( new ImageIcon( laImagen ) );
 
                txtDirector.setText( equipoActual.darDirector( ) );
 
            }
 
            catch( IOException e1 )
 
            {
 
                JOptionPane.showMessageDialog( this, "Problemas cargando la bandera del equipo", "Error", JOptionPane.ERROR_MESSAGE );
 
            }
 

 
        }
 

 
    }
 

 
    /**
 
     * Actualiza la información en el panel con la lista de equipos
 
     * @param equipos la lista de equipos a desplegar - equipos!=null
 
     */
 
    public void refrescarEquipos( ArrayList equipos )
 
    {
 
        comboEquipos.removeAllItems( );
 

 
        for( int i = 0; i < equipos.size( ); i++ )
 
        {
 
            comboEquipos.addItem( equipos.get( i ) );
 
        }
 
    }
 

 
    /**
 
     * Este es el método que se ejecuta cuando se cambia el equipo seleccionado en el combobox
 
     * @param evento El evento de la selección de un equipo diferente - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( CAMBIAR_EQUIPO.equals( comando ) )
 
        {
 
            String nombreEquipo = ( String )comboEquipos.getSelectedItem( );
 
            principal.cambiarEquipoSeleccionado( nombreEquipo );
 

 
        }
 

 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 * $Id: PanelImagen.java,v 1.1 2006/11/27 00:13:09 da-romer Exp $ 
 
 * Universidad de los Andes (Bogotá - Colombia) 
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Todos los derechos reservados 2005 
 
 * 
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Color;
 
import java.awt.FlowLayout;
 

 
import javax.swing.ImageIcon;
 
import javax.swing.JLabel;
 
import javax.swing.JPanel;
 
import javax.swing.border.LineBorder;
 

 
/**
 
 * Es el panel donde se muestra una imagen decorativa
 
 */
 
public class PanelImagen extends JPanel
 
{
 

 
    // -----------------------------------------------------------------
 
    // Atributos de Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Imagen del titulo
 
     */
 
    private JLabel imagen;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constructor del panel
 
     */
 
    public PanelImagen( )
 
    {
 
        FlowLayout layout = new FlowLayout( );
 
        layout.setHgap( 0 );
 
        layout.setVgap( 0 );
 
        setLayout( layout );
 
        //
 
        // Carga la imagen
 
        ImageIcon icono = new ImageIcon( "data/titulo.png" );
 

 
        // La agrega a la etiqueta
 
        imagen = new JLabel( "" );
 
        imagen.setIcon( icono );
 
        add( imagen );
 
        //
 
        // Color de fondo blanco
 
        setBackground( Color.WHITE );
 
        setBorder( new LineBorder( Color.GRAY ) );
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelJugadores.java,v 1.7 2006/12/01 22:29:13 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.Font;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Insets;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 
import java.util.ArrayList;
 

 
import javax.swing.ImageIcon;
 
import javax.swing.JComboBox;
 
import javax.swing.JLabel;
 
import javax.swing.JPanel;
 
import javax.swing.border.CompoundBorder;
 
import javax.swing.border.EmptyBorder;
 
import javax.swing.border.TitledBorder;
 

 
import uniandes.cupi2.mundial.mundo.Equipo;
 
import uniandes.cupi2.mundial.mundo.Jugador;
 

 
/**
 
 * Es el panel con los jugadores de un equipo
 
 */
 
public class PanelJugadores extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Comando para cambiar el jugador
 
     */
 
    private static final String CAMBIAR_JUGADOR = "CambiarJugador";
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * El jugador del que actualmente se presentan los datos en el panel
 
     */
 
    private Jugador jugador;
 

 
    // -----------------------------------------------------------------
 
    // Atributos de interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el panel para presentar los datos del jugador
 
     */
 
    private InterfazMundial principal;
 

 
    /**
 
     * Es la etiqueta que muestra la imagen del jugador
 
     */
 
    private JLabel etiquetaImagen;
 

 
    /**
 
     * Es el combo con los jugadores del equipo
 
     */
 
    private JComboBox comboJugadores;
 

 
    /**
 
     * Etiqueta "Nombre: "
 
     */
 
    private JLabel etiquetaNombre;
 

 
    /**
 
     * Etiqueta "Edad: "
 
     */
 
    private JLabel etiquetaEdad;
 

 
    /**
 
     * Es la etiqueta con la edad del jugador
 
     */
 
    private JLabel etiquetaValorEdad;
 

 
    /**
 
     * Etiqueta "Posición: "
 
     */
 
    private JLabel etiquetaPosicion;
 

 
    /**
 
     * Es la etiqueta con la posición del jugador
 
     */
 
    private JLabel etiquetaValorPosicion;
 

 
    /**
 
     * Etiqueta "Altura: "
 
     */
 
    private JLabel etiquetaAltura;
 

 
    /**
 
     * Es la etiqueta con la altura del jugador
 
     */
 
    private JLabel etiquetaValorAltura;
 

 
    /**
 
     * Etiqueta "Peso: "
 
     */
 
    private JLabel etiquetaPeso;
 

 
    /**
 
     * Es la etiqueta con el peso del jugador
 
     */
 
    private JLabel etiquetaValorPeso;
 

 
    /**
 
     * Etiqueta salario
 
     */
 
    private JLabel etiquetaSalario;
 

 
    /**
 
     * Es la etiqueta con el salario del jugador
 
     */
 
    private JLabel etiquetaValorSalario;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Constructor del panel
 
     * @param ventana Ventana principal - ventana!=null
 
     */
 
    public PanelJugadores( InterfazMundial ventana )
 
    {
 
        principal = ventana;
 
        setLayout( new GridBagLayout( ) );
 
        GridBagConstraints c = new GridBagConstraints( 0, 1, 1, 1, 1, 0.2, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 

 
        // Foto del jugador
 
        etiquetaImagen = new JLabel( "" );
 
        etiquetaImagen.setPreferredSize( new Dimension( 150, 180 ) );
 
        etiquetaImagen.setBorder( new EmptyBorder( 10, 10, 10, 10 ) );
 

 
        c = new GridBagConstraints( 0, 0, 1, 6, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaImagen, c );
 

 
        // Nombre
 
        etiquetaNombre = new JLabel( "Nombre: " );
 
        c = new GridBagConstraints( 1, 0, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaNombre, c );
 

 
        comboJugadores = new JComboBox( );
 
        comboJugadores.setEditable( false );
 
        comboJugadores.addActionListener( this );
 
        comboJugadores.setActionCommand( CAMBIAR_JUGADOR );
 
        comboJugadores.setPreferredSize( new Dimension( 230, 20 ) );
 
        c = new GridBagConstraints( 2, 0, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( comboJugadores, c );
 

 
        // Edad
 
        etiquetaEdad = new JLabel( "Edad: " );
 
        etiquetaValorEdad = new JLabel( "" );
 
        etiquetaValorEdad.setFont( etiquetaValorEdad.getFont( ).deriveFont( Font.PLAIN ) );
 
        c = new GridBagConstraints( 1, 1, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaEdad, c );
 
        c = new GridBagConstraints( 2, 1, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaValorEdad, c );
 

 
        // Posición
 
        etiquetaPosicion = new JLabel( "Posición: " );
 
        etiquetaValorPosicion = new JLabel( "" );
 
        etiquetaValorPosicion.setFont( etiquetaValorPosicion.getFont( ).deriveFont( Font.PLAIN ) );
 
        c = new GridBagConstraints( 1, 2, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaPosicion, c );
 
        c = new GridBagConstraints( 2, 2, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaValorPosicion, c );
 

 
        // Altura
 
        etiquetaAltura = new JLabel( "Altura: " );
 
        etiquetaValorAltura = new JLabel( "" );
 
        etiquetaValorAltura.setFont( etiquetaValorAltura.getFont( ).deriveFont( Font.PLAIN ) );
 
        c = new GridBagConstraints( 1, 3, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaAltura, c );
 
        c = new GridBagConstraints( 2, 3, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaValorAltura, c );
 

 
        // Peso
 
        etiquetaPeso = new JLabel( "Peso: " );
 
        etiquetaValorPeso = new JLabel( "" );
 
        etiquetaValorPeso.setFont( etiquetaValorPeso.getFont( ).deriveFont( Font.PLAIN ) );
 
        c = new GridBagConstraints( 1, 4, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaPeso, c );
 
        c = new GridBagConstraints( 2, 4, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaValorPeso, c );
 

 
        // Salario
 
        etiquetaSalario = new JLabel( "Salario: " );
 
        etiquetaValorSalario = new JLabel( "" );
 
        etiquetaValorSalario.setFont( etiquetaValorSalario.getFont( ).deriveFont( Font.PLAIN ) );
 
        c = new GridBagConstraints( 1, 5, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaSalario, c );
 
        c = new GridBagConstraints( 2, 5, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( etiquetaValorSalario, c );
 

 
        setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Jugadores" ) ) );
 

 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Cambia el jugador actual
 
     * @param j El nuevo jugador actual - j!=null
 
     */
 
    public void cambiarJugador( Jugador j )
 
    {
 
        jugador = j;
 
        etiquetaImagen.setIcon( new ImageIcon( jugador.darImagen( ) ) );
 
        etiquetaValorEdad.setText( Integer.toString( jugador.darEdad( ) ) + " años" );
 
        etiquetaValorPosicion.setText( jugador.darPosicion( ) );
 
        etiquetaValorAltura.setText( Double.toString( jugador.darAltura( ) ) + " mts" );
 
        etiquetaValorPeso.setText( Double.toString( jugador.darPeso( ) ) + " Kgs" );
 
        etiquetaValorSalario.setText( principal.formatearValor( jugador.darSalario( ) ) + " millones anuales" );
 

 
    }
 

 
    /**
 
     * Cambia los jugadores del equipo que se muestran en el panel
 
     * @param e El nuevo equipo a mostrar en el panel - e!=null
 
     */
 
    public void cambiarJugadores( Equipo e )
 
    {
 
        if( e != null )
 
        {
 
            cambiarEquipo( e );
 
        }
 
        else
 
        {
 
            setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Jugadores" ) ) );
 
        }
 
    }
 

 
    /**
 
     * Cambia el equipo para el cual se muestran los jugadores en el panel y actualiza la información mostrada
 
     * @param e Es el equipo del que se quieren mostrar los jugadores - e!=null
 
     */
 
    private void cambiarEquipo( Equipo e )
 
    {
 
        comboJugadores.removeAllItems( );
 
        ArrayList jugadores = e.darNombresJugadores( );
 
        for( int i = 0; i < jugadores.size( ); i++ )
 
        {
 
            String jugador = ( String )jugadores.get( i );
 
            comboJugadores.addItem( jugador );
 
        }
 
        if( jugadores.size( ) == 0 )
 
        {
 
            etiquetaImagen.setIcon( new ImageIcon( "./data/sinFoto.img" ) );
 
            etiquetaValorEdad.setText( "" );
 
            etiquetaValorPosicion.setText( "" );
 
            etiquetaValorAltura.setText( "" );
 
            etiquetaValorPeso.setText( "" );
 
            etiquetaValorSalario.setText( "" );
 
        }
 
    }
 

 
    /**
 
     * Ejecuta las acciones asociadas a los eventos. Actualiza la información del jugador en el panel de acuerdo al jugador seleccionado en el comboBox
 
     * @param evento Es el evento del click sobre un botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( CAMBIAR_JUGADOR.equals( comando ) )
 
        {
 
            String nombreJugador = ( String )comboJugadores.getSelectedItem( );
 
            principal.cambiarJugadorSeleccionado( nombreJugador );
 

 
        }
 
    }
 

 
}

 
/** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: ArchivoJugadoresException.java,v 1.2 2006/12/01 21:18:19 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License versión 2.1
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 25-ago-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
/**
 
 * Esta excepción sirve para indicar que hubo un problema procesando el archivo con la información de los jugadores a modificar
 
 */
 
public class ArchivoJugadoresException extends Exception
 
{
 
    // -----------------------------------------------------------------
 
    // Constructor
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye la excepción con una causa del error
 
     * @param causa El mensaje que describe el problema que se presentó
 
     */
 
    public ArchivoJugadoresException( String causa )
 
    {
 
        super( causa );
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: ElementoExisteException.java,v 1.1 2006/08/28 20:25:13 f-vela Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 25-ago-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
/**
 
 * Esta excepción se lanza cuando se intenta agregar al mundial un elemento repetido. <br>
 
 * El mensaje asociado con la excepción debe indicar el equipo o el jugador que causó el error.
 
 */
 
public class ElementoExisteException extends Exception
 
{
 
    // -----------------------------------------------------------------
 
    // Constructor
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye la excepción indicando el equipo o el jugador que causó el error
 
     * @param nomElem nombre del elemento repetido
 
     */
 
    public ElementoExisteException( String nomElem )
 
    {
 
        super( nomElem );
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: Equipo.java,v 1.7 2006/12/01 22:29:13 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
import java.io.Serializable;
 
import java.util.ArrayList;
 

 
/**
 
 * Es la clase que representa un equipo del mundial <br>
 
 * <b>inv: </b> <br>
 
 * jugadores != null <br>
 
 * pais != null <br>
 
 * director != null <br>
 
 * imagen != null <br>
 
 * No hay dos o más jugadores con el mismo nombre <br>
 
 */
 

 
public class Equipo implements Serializable
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Indicador de versión para la serialización
 
     */
 
    private static final long serialVersionUID = 200L;
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el vector con los jugadores del equipo
 
     */
 
    private ArrayList jugadores;
 

 
    /**
 
     * Es el nombre del país que representa el equipo
 
     */
 
    private String pais;
 

 
    /**
 
     * Es el nombre del director técnico del equipo
 
     */
 
    private String director;
 

 
    /**
 
     * Es la ruta de la imagen con la bandera del equipo
 
     */
 
    private String imagen;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye un nuevo Equipo con los datos suministrados y sin jugadores
 
     * @param paisE Es el país del equipo - paisE != null
 
     * @param directorE Es el nombre del director técnico del equipo - directorE != null
 
     * @param imagenE Es la bandera del equipo - imagenE != null
 
     */
 
    public Equipo( String paisE, String directorE, String imagenE )
 
    {
 
        jugadores = new ArrayList( );
 
        pais = paisE;
 
        director = directorE;
 
        imagen = imagenE;
 

 
        verificarInvariante( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna un jugador del equipo dado su nombre.
 
     * @param nombreJ Es el nombre del jugador a buscar - nombreJ != null
 
     * @return El jugador cuyo nombre es igual al nombre dado. Si no se encontró retorna null.
 
     */
 
    public Jugador darJugador( String nombreJ )
 
    {
 
        Jugador jugadorBuscado = null;
 
        boolean esta = false;
 

 
        for( int i = 0; i < jugadores.size( ) && !esta; i++ )
 
        {
 
            Jugador j = ( Jugador )jugadores.get( i );
 
            if( j.darNombre( ).equalsIgnoreCase( nombreJ ) )
 
            {
 
                jugadorBuscado = j;
 
                esta = true;
 
            }
 
        }
 
        return jugadorBuscado;
 
    }
 

 
    /**
 
     * Adiciona un jugador al equipo. <br>
 
     * <b>post: </b> El jugador j ha sido agregado al equipo
 
     * @param j El nuevo jugador para adicionar al equipo - j!=null
 
     * @throws ElementoExisteException Si ya existía un jugador con el mismo nombre
 
     */
 
    public void agregarJugador( Jugador j ) throws ElementoExisteException
 
    {
 
        if( darJugador( j.darNombre( ) ) != null )
 
            throw new ElementoExisteException( "El jugador " + j.darNombre( ) + " ya existe en el equipo" );
 

 
        jugadores.add( j );
 

 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Retorna el país del equipo
 
     * @return Se retornó el país al que pertenece el equipo
 
     */
 
    public String darPais( )
 
    {
 
        return pais;
 
    }
 

 
    /**
 
     * Retorna el nombre del director técnico del equipo
 
     * @return Se retornó el director del equipo
 
     */
 
    public String darDirector( )
 
    {
 
        return director;
 
    }
 

 
    /**
 
     * Retorna la ruta de la imagen con la bandera del equipo
 
     * @return Se retornó la ruta de la imagen
 
     */
 
    public String darImagen( )
 
    {
 
        return imagen;
 
    }
 

 
    /**
 
     * Retorna el vector con los nombres de las jugadores del equipo
 
     * @return Se retornó el vector con los nombres de los jugadores
 
     */
 
    public ArrayList darNombresJugadores( )
 
    {
 
        ArrayList nombresJugadores = new ArrayList( );
 
        for( int i = 0; i < jugadores.size( ); i++ )
 
        {
 
            Jugador j = ( Jugador )jugadores.get( i );
 
            nombresJugadores.add( j.darNombre( ) );
 
        }
 
        return nombresJugadores;
 
    }
 

 
    /**
 
     * Calcula el valor de la nómina del equipo
 
     * @return Se retornó el valor de la nómina del equipo
 
     */
 
    public double calcularValorNomina( )
 
    {
 
        double valorTotal = 0;
 
        for( int i = 0; i < jugadores.size( ); i++ )
 
        {
 
            Jugador j = ( Jugador )jugadores.get( i );
 
            valorTotal = valorTotal + j.darSalario( );
 
        }
 
        return valorTotal;
 
    }
 

 
    /**
 
     * Modificación la información del jugador con el nombre dado. <br>
 
     * <b>pre: </n> nombre pertenece a unos de los jugadores del equipo. <br>
 
     * @param nombre El nombre del jugador al que se le va a modificar la información - nombre!=null
 
     * @param edad La nueva edad del jugador - edad>0
 
     * @param posicion La nueva posición del jugador - posiciom!=null
 
     * @param altura La nueva altura del jugador - altura>0
 
     * @param peso El nuevo peso del jugador - peso>0
 
     * @param salario El nuevo salario del jugador - salario>0
 
     * @param imagen La nueva imagen del jugador - imagen!=null
 
     */
 
    public void modificarInformacionJugador( String nombre, int edad, String posicion, double altura, double peso, double salario, String imagen )
 
    {
 
        Jugador jugador = darJugador( nombre );
 
        jugador.cambiarAltura( altura );
 
        jugador.cambiarEdad( edad );
 
        jugador.cambiarImagen( imagen );
 
        jugador.cambiarPeso( peso );
 
        jugador.cambiarPosicion( posicion );
 
        jugador.cambiarSalario( salario );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Invariante
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Verifica el invariante de la clase: <br>
 
     * jugadores != null <br>
 
     * pais != null <br>
 
     * director != null <br>
 
     * imagen != null <br>
 
     * No hay dos o más jugadores con el mismo nombre <br>
 
     */
 
    private void verificarInvariante( )
 
    {
 
        assert jugadores != null : "La lista de jugadores no debe ser nula";
 
        assert pais != null : "El país del equipo es inválido";
 
        assert director != null : "El director técnico es inválido";
 
        assert imagen != null : "La ruta de la imagen es inválida";
 
        assert !buscarJugadoresConElMismoNombre( ) : "Hay dos jugadores con el mismo nombre";
 
    }
 

 
    /**
 
     * Este método sirve para revisar si hay jugadores repetidos dentro del equipo.
 
     * @return Retorna true si hay un jugador que aparece repetido dentro de la lista de jugadores. Retorna false en caso contrario.
 
     */
 
    private boolean buscarJugadoresConElMismoNombre( )
 
    {
 
        for( int i = 0; i < jugadores.size( ); i++ )
 
        {
 
            Jugador j1 = ( Jugador )jugadores.get( i );
 
            for( int j = 0; j < jugadores.size( ); j++ )
 
            {
 
                if( i != j )
 
                {
 
                    Jugador j2 = ( Jugador )jugadores.get( j );
 
                    if( j1.darNombre( ).equalsIgnoreCase( j2.darNombre( ) ) )
 
                    {
 
                        return true;
 
                    }
 
                }
 
            }
 
        }
 
        return false;
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: Jugador.java,v 1.8 2006/12/01 22:29:13 da-romer Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
import java.io.Serializable;
 

 
/**
 
 * Es la clase que representa un jugador que hace parte de un equipo <br>
 
 * <b>inv: </b> <br>
 
 * nombre != null <br>
 
 * edad > 0 <br>
 
 * posicion != null <br>
 
 * altura > 0 <br>
 
 * peso > 0 <br>
 
 * salario > 0 <br>
 
 * imagen != null <br>
 
 */
 
public class Jugador implements Serializable
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Indicador de versión para la serialización
 
     */
 
    private static final long serialVersionUID = 100L;
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es el nombre del jugador
 
     */
 
    private String nombre;
 

 
    /**
 
     * Es la edad del jugador
 
     */
 
    private int edad;
 

 
    /**
 
     * Es la posición en la que juega el jugador
 
     */
 
    private String posicion;
 

 
    /**
 
     * Es la altura del jugador en metros
 
     */
 
    private double altura;
 

 
    /**
 
     * Es el peso en kilogramos del jugador
 
     */
 
    private double peso;
 

 
    /**
 
     * Es el salario anual del jugador en millones de pesos
 
     */
 
    private double salario;
 

 
    /**
 
     * Es la ruta a la imagen con la foto del jugador
 
     */
 
    private String imagen;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye un jugador con los datos suministrados
 
     * @param nombreJ El nombre del jugador - nombreJ != null
 
     * @param edadJ La edad del jugador - edadJ > 0
 
     * @param posicionJ La posición en la que juega el jugador - posicionJ != null
 
     * @param alturaJ Es la altura del jugador en metros - alturaJ > 0
 
     * @param pesoJ Es el peso del jugador en kilogramos - pesoJ > 0
 
     * @param salarioJ Es el salario del jugador - salarioJ > 0
 
     * @param imagenJ Es el salario del jugador - imagenJ != null
 
     */
 
    public Jugador( String nombreJ, int edadJ, String posicionJ, double alturaJ, double pesoJ, double salarioJ, String imagenJ )
 
    {
 
        nombre = nombreJ;
 
        edad = edadJ;
 
        posicion = posicionJ;
 
        altura = alturaJ;
 
        peso = pesoJ;
 
        salario = salarioJ;
 
        imagen = imagenJ;
 

 
        verificarInvariante( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna el nombre del jugador
 
     * @return Se retornó el nombre del jugador
 
     */
 
    public String darNombre( )
 
    {
 
        return nombre;
 
    }
 

 
    /**
 
     * Retorna la edad del jugador
 
     * @return Se retornó la edad del jugador
 
     */
 
    public int darEdad( )
 
    {
 
        return edad;
 
    }
 

 
    /**
 
     * Retorna la posición del jugador
 
     * @return Se retornó la posición del jugador
 
     */
 
    public String darPosicion( )
 
    {
 
        return posicion;
 
    }
 

 
    /**
 
     * Retorna la altura del jugador
 
     * @return Se retornó la altura del jugador
 
     */
 
    public double darAltura( )
 
    {
 
        return altura;
 
    }
 

 
    /**
 
     * Retorna el peso del jugador
 
     * @return Se retornó el peso del jugador
 
     */
 
    public double darPeso( )
 
    {
 
        return peso;
 
    }
 

 
    /**
 
     * Retorna el salario del jugador
 
     * @return Se retornó el salario del jugador
 
     */
 
    public double darSalario( )
 
    {
 
        return salario;
 
    }
 

 
    /**
 
     * Retorna la ruta de la imagen del jugador
 
     * @return Se retornó la ruta de la imagen del jugador
 
     */
 
    public String darImagen( )
 
    {
 
        return imagen;
 
    }
 

 
    /**
 
     * Cambia la altura del jugador
 
     * @param nAltura Nueva altura del jugador - altura>0
 
     */
 
    public void cambiarAltura( double nAltura )
 
    {
 
        altura = nAltura;
 
    }
 

 
    /**
 
     * Cambia la edad del jugador
 
     * @param nEdad Nueva edad del jugador - nEdad>0
 
     */
 
    public void cambiarEdad( int nEdad )
 
    {
 
        edad = nEdad;
 
    }
 

 
    /**
 
     * Cambia la imagen del jugador
 
     * @param nImagen Nueva imagen del jugador - imagen!=null
 
     */
 
    public void cambiarImagen( String nImagen )
 
    {
 
        imagen = nImagen;
 
    }
 

 
    /**
 
     * Cambia el peso del jugador
 
     * @param nPeso Nuevo peso del jugador - nPeso>0
 
     */
 
    public void cambiarPeso( double nPeso )
 
    {
 
        peso = nPeso;
 
    }
 

 
    /**
 
     * Cambia la posición del jugador
 
     * @param nPosicion Nueva posición del jugador - nPosicion!=null
 
     */
 
    public void cambiarPosicion( String nPosicion )
 
    {
 
        posicion = nPosicion;
 
    }
 

 
    /**
 
     * Cambia el salario del jugador
 
     * @param nSalario Nueva salario del jugador - nSalario>0
 
     */
 
    public void cambiarSalario( double nSalario )
 
    {
 
        salario = nSalario;
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Invariante
 
    // -----------------------------------------------------------------
 
    /**
 
     * Verifica el invariante de la clase. <br>
 
     * <b>inv: </b> <br>
 
     * nombre != null <br>
 
     * edad > 0 <br>
 
     * posicion != null <br>
 
     * altura > 0 <br>
 
     * peso > 0 <br>
 
     * salario > 0 <br>
 
     * imagen != null <br>
 
     */
 
    private void verificarInvariante( )
 
    {
 
        assert nombre != null : "El nombre es inválido";
 
        assert edad > 0 : "La edad deben ser un entero positivo";
 
        assert posicion != null : "La posición es inválida";
 
        assert altura > 0 : "La altura debe ser un double positivo";
 
        assert peso > 0 : "El peso debe ser un double positivo";
 
        assert salario > 0 : "El salario debe ser un double positivo";
 
        assert imagen != null : "La ruta de la imagen es inválida";
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: Mundial.java,v 1.10 2007/03/17 15:19:21 jvillalo2 Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 10-may-2006
 
 * Autor: Daniel Romero - 30-nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
import java.io.BufferedReader;
 
import java.io.File;
 
import java.io.FileInputStream;
 
import java.io.FileOutputStream;
 
import java.io.FileReader;
 
import java.io.FileWriter;
 
import java.io.IOException;
 
import java.io.ObjectInputStream;
 
import java.io.ObjectOutputStream;
 
import java.io.PrintWriter;
 
import java.util.ArrayList;
 
import java.util.Date;
 

 
/**
 
 * Es la clase para representar el mundial de fútbol <br>
 
 * <b>inv: </b> <br>
 
 * equipos != null <br>
 
 * No hay dos equipos del mismo país
 
 * 
 
 */
 

 
public class Mundial
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Nombre del archivo de registro de errores del programa
 
     */
 
    private static final String LOG_FILE = "./data/error.log";
 

 
    /**
 
     * Número de datos a leer para un equipo
 
     */
 
    public static final int DATOS_EQUIPO = 4;
 

 
    /**
 
     * Número de datos a leer para un jugador
 
     */
 
    public static final int DATOS_JUGADOR = 7;
 

 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * La lista de equipos del mundial
 
     */
 
    private ArrayList equipos;
 

 
    /**
 
     * Es el archivo de donde se cargan y salvan los equipos
 
     */
 
    private String archivoMundial;
 

 
    // -----------------------------------------------------------------
 
    // Constructores
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye un nuevo mundial de fútbol. <br>
 
     * Si el archivo indicado no existe, entonces el mundial se crea vacío y su estado se guardará en el archivo indicado.<br>
 
     * Si el archivo existe, entonces de él se saca la información de los equipos y jugadores.
 
     * @param nombreArchivoMundial Es el nombre del archivo que contiene los datos del mundial
 
     * @throws PersistenciaException Se lanza esta excepción si se encuentran problemas cargando los datos del archivo
 
     */
 
    public Mundial( String nombreArchivoMundial ) throws PersistenciaException
 
    {
 
        archivoMundial = nombreArchivoMundial;
 
        File archivo = new File( archivoMundial );
 
        if( archivo.exists( ) )
 
        {
 
            // El archivo existe: se debe recuperar de allí el estado del modelo del mundo
 
            try
 
            {
 
                ObjectInputStream ois = new ObjectInputStream( new FileInputStream( archivo ) );
 
                equipos = ( ArrayList )ois.readObject( );
 
                ois.close( );
 
            }
 
            catch( Exception e )
 
            {
 
                // Se atrapan en este bloque todos los tipos de excepción
 
                registrarError( e );
 
                throw new PersistenciaException( "Error fatal: imposible restaurar el estado del programa (" + e.getMessage( ) + ")" );
 
            }
 
        }
 
        else
 
        {
 
            // El archivo no existe: es la primera vez que se ejecuta el programa
 
            equipos = new ArrayList( );
 
        }
 
        verificarInvariante( );
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Métodos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Retorna un equipo del mundial dado su país.
 
     * @param nombreEquipo el nombre del equipo a buscar - nombreEquipo != null
 
     * @return El equipo cuyo nombre es igual al nombre dado. Si no se encontró se retorna null.
 
     */
 
    public Equipo darEquipo( String nombreEquipo )
 
    {
 
        Equipo equipoBuscado = null;
 
        boolean esta = false;
 

 
        for( int i = 0; i < equipos.size( ) && !esta; i++ )
 
        {
 
            Equipo e = ( Equipo )equipos.get( i );
 
            if( e.darPais( ).equalsIgnoreCase( nombreEquipo ) )
 
            {
 
                equipoBuscado = e;
 
                esta = true;
 
            }
 
        }
 
        return equipoBuscado;
 
    }
 

 
    /**
 
     * Agrega un nuevo equipo al mundial
 
     * @param pais El nombre del país que representa el equipo - pais != null
 
     * @param director El nombre del director técnico del equipo - director != null
 
     * @param imagen La imagen con la bandera del país del equipo - imagen != null
 
     * @throws ElementoExisteException Esta excepción se lanza si ya existe un equipo con el mismo nombre
 
     */
 
    public void agregarEquipo( String pais, String director, String imagen ) throws ElementoExisteException
 
    {
 
        if( darEquipo( pais ) != null )
 
            throw new ElementoExisteException( "El equipo " + pais + " ya existe en el mundial" );
 

 
        Equipo equipo = new Equipo( pais, director, imagen );
 
        equipos.add( equipo );
 

 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Retorna un vector con los nombres de los equipos
 
     * @return Vector con los nombres de los equipos
 
     */
 
    public ArrayList darNombresEquipos( )
 
    {
 
        ArrayList nombresEquipos = new ArrayList( );
 
        for( int i = 0; i < equipos.size( ); i++ )
 
        {
 
            Equipo e = ( Equipo )equipos.get( i );
 
            nombresEquipos.add( e.darPais( ) );
 
        }
 
        return nombresEquipos;
 
    }
 

 
    /**
 
     * Agrega un nuevo jugador al equipo
 
     * @param nombreEquipo El nombre del equipo para adicionar el jugador - hay un equipo con ese nombre en el mundial
 
     * @param nombreJ El nombre del jugador a crear - nombreJ != null
 
     * @param edadJ El número de años del jugador - edadJ > 0
 
     * @param posicionJ La posición en la que juega el jugador - posicionJ != null
 
     * @param alturaJ La altura en metros del jugador - alturaJ > 0
 
     * @param pesoJ El peso en kilogramos del jugador - pesoJ > 0
 
     * @param salarioJ El salario anual del jugador en millones de dólares - salarioJ > 0
 
     * @param imagenJ La ruta de la imagen con la foto del jugador - imagenJ != null
 
     * @throws ElementoExisteException Esta excepción se lanza si ya existe otro jugador en el equipo con el mismo nombre
 
     */
 
    public void agregarJugadorAEquipo( String nombreEquipo, String nombreJ, int edadJ, String posicionJ, double alturaJ, double pesoJ, double salarioJ, String imagenJ ) throws ElementoExisteException
 
    {
 
        Equipo e = darEquipo( nombreEquipo );
 
        e.agregarJugador( new Jugador( nombreJ, edadJ, posicionJ, alturaJ, pesoJ, salarioJ, imagenJ ) );
 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Calcula el valor de la nómina de un equipo y genera el reporte correspondiente
 
     * @param nombreEquipo El nombre del equipo para el que se va a calcular el valor de la nómina
 
     * @param rutaReporte el directorio donde debe generarse el reporte - rutaReporte != null
 
     * @return Retorna el nombre del archivo en el que se generó el reporte
 
     * @throws IOException Se genera esta excepción si hay problemas salvando el archivo con el reporte
 
     */
 
    public String calcularValorNomina( String nombreEquipo, String rutaReporte ) throws IOException
 
    {
 
        // Genera el nombre para el archivo con el reporte de la nómina
 
        String strTiempo = Long.toString( System.currentTimeMillis( ) );
 
        String nombreArchivo = nombreEquipo + "_" + strTiempo + ".nomina";
 

 
        // Guarda el archivo con el reporte
 
        File directorioReportes = new File( rutaReporte );
 
        if( !directorioReportes.exists( ) )
 
            directorioReportes.mkdirs( );
 
        File archivoReporte = new File( directorioReportes, nombreArchivo );
 
        PrintWriter out = new PrintWriter( archivoReporte );
 

 
        Date fecha = new Date( );
 
        out.println( "Mundial_CUPI2 - Reporte Nómina - Equipo: " + nombreEquipo );
 
        out.println( "Fecha:            " + fecha.toString( ) );
 
        out.println( "Total Nómina:          " + darEquipo( nombreEquipo ).calcularValorNomina( ) + " millones anuales" );
 
        out.close( );
 

 
        return nombreArchivo;
 

 
    }
 

 
    /**
 
     * Actualiza la información de los jugadores a partir de la información contenida en un archivo de texto.<br>
 
     * El archivo debe tener una línea en la cual se encuentra el número de jugadores a los que se les va a modificar la información, <br>
 
     * y luego debe haber una línea por cada jugador al que se le va a modificar la información. <br>
 
     * Cada línea tiene el siguiente formato: <nombre país>;<nombre jugador>;<edad>;<posición>;<altura>;<peso>;<salario>;<imágen>
 
     * @param archivo El archivo que tiene la información de los jugadores - archivo!= null
 
     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo de los jugadores
 
     * @throws ArchivoJugadoresException Se lanza esta excepción si el archivo no cumple con el formato esperado
 
     */
 
    public void modificarInformacionJugadores( File archivo ) throws ArchivoJugadoresException, IOException
 
    {
 

 
        String linea = null;
 
        int numeroJugadores = -1;
 

 
        // Abre el archivo con los equipos y jugadores. Si no existe, el constructor del flujo lanza la excepción FileNotFoundException
 
        BufferedReader lector = new BufferedReader( new FileReader( archivo ) );
 

 
        // Lee la primera línea del archivo (el número de equipos)
 
        linea = lector.readLine( );
 

 
        if( linea != null && !linea.equals( "" ) )
 
        {
 
            linea = linea.trim( );
 

 
            try
 
            {
 
                numeroJugadores = Integer.parseInt( linea );
 
            }
 
            catch( NumberFormatException e )
 
            {
 
                // Hubo un error al leer el número de jugadores
 
                throw new ArchivoJugadoresException( "El archivo no tiene el formato esperado. Se esperaba el número de jugadores" );
 
            }
 
            int cont = 0;
 

 
            linea = lector.readLine( );
 
            linea = linea.trim( );
 

 
            while( cont < numeroJugadores )
 
            {
 
                modificarJugador( linea );
 
                linea = lector.readLine( );
 
                cont++;
 

 
                if( linea != null )
 
                {
 
                    linea = linea.trim( );
 

 
                }
 
                else if( cont < numeroJugadores )
 
                {
 
                    throw new ArchivoJugadoresException( "El archivo no tiene el formato esperado. Se esperaba la información de " + numeroJugadores + " jugadores" );
 
                }
 
            }
 

 
        }
 
        else
 
        {
 
            // Hubo un error al leer el número de jugadores
 
            throw new ArchivoJugadoresException( "El archivo no tiene el formato esperado. Se esperaba el número de jugadores" );
 
        }
 

 
        lector.close( );
 

 
    }
 

 
    /**
 
     * Carga un equipo a partir de la información contenida en un archivo
 
     * @param br Es el lector de archivo del cual se lee la información del equipo - El lector de archivo ya está listo para leer
 
     * @throws ArchivoJugadoresException Se lanza esta excepción si el archivo no tiene el formato esperado
 
     * @throws IOException Si hay errores leyendo la siguiente línea del archivo
 
     * @throws ArchivoJugadoresException Si la línea del archivo no tiene el formato esperado
 
     */
 

 
    private void modificarJugador( String info ) throws ArchivoJugadoresException, IOException
 
    {
 
        String[] nuevosDatos = info.split( ";" );
 
        // Verificar que se tengan los 8 datos del jugador
 
        if( nuevosDatos.length == 8 )
 
        {
 
            String nombreEquipo = nuevosDatos[ 0 ];
 
            String nombreJugador = nuevosDatos[ 1 ];
 
            Equipo equipo = darEquipo( nombreEquipo );
 

 
            if( equipo != null )
 
            {
 
                if( equipo.darJugador( nombreJugador ) != null )
 
                {
 
                    int edad = Integer.parseInt( nuevosDatos[ 2 ] );
 
                    String posicion = nuevosDatos[ 3 ];
 
                    double altura = Double.parseDouble( nuevosDatos[ 4 ] );
 
                    double peso = Double.parseDouble( nuevosDatos[ 5 ] );
 
                    double salario = Double.parseDouble( nuevosDatos[ 6 ] );
 
                    String imagen = nuevosDatos[ 7 ];
 

 
                    if( edad < 0 || posicion.equals( "" ) || altura < 0 || peso < 0 || salario < 0 || imagen.equals( "" ) )
 
                    {
 
                        throw new ArchivoJugadoresException( "La datos del jugador " + nombreJugador + " no son válidos" );
 
                    }
 

 
                    equipo.modificarInformacionJugador( nombreJugador, edad, posicion, altura, peso, salario, imagen );
 
                }
 
                else
 
                {
 
                    throw new ArchivoJugadoresException( "El jugador con nombre " + nombreJugador + " no se encuentra en el campeonato" );
 
                }
 
            }
 
            else
 
            {
 
                throw new ArchivoJugadoresException( "El archivo no tiene el formato esperado. El equipo con nombre " + nombreEquipo + " no se encuentra en el campeonato" );
 
            }
 
        }
 
        else
 
        {
 
            throw new ArchivoJugadoresException( "El archivo no tiene el formato esperado. Se esperaban los ocho datos del jugador" );
 
        }
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Persistencia
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Salva el mundial en un archivo binario
 
     * @throws PersistenciaException Se lanza esta excepción si hay problemas guardando la información del mundial en el archivo
 
     */
 
    public void salvarMundial( ) throws PersistenciaException
 
    {
 
        try
 
        {
 
            ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream( archivoMundial ) );
 
            oos.writeObject( equipos );
 
            oos.close( );
 
        }
 
        catch( IOException e )
 
        {
 
            registrarError( e );
 
            throw new PersistenciaException( "Error al salvar: " + e.getMessage( ) );
 
        }
 
    }
 

 
    /**
 
     * Registra en el archivo de log del programa toda la información referente a una excepción, ocurrida durante el proceso de persistencia
 
     * @param excepcion Es la excepción que contiene la información del error
 
     */
 
    public void registrarError( Exception excepcion )
 
    {
 
        try
 
        {
 
            FileWriter out = new FileWriter( LOG_FILE, true );
 
            PrintWriter log = new PrintWriter( out );
 
            log.println( "---------------------------------------" );
 
            log.println( "Mundial.java :" + new Date( ).toString( ) );
 
            log.println( "---------------------------------------" );
 
            excepcion.printStackTrace( log );
 
            log.close( );
 
            out.close( );
 
        }
 
        catch( IOException e )
 
        {
 
            excepcion.printStackTrace( );
 
            e.printStackTrace( );
 
        }
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Invariante
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Verifica el invariante de la clase: <br>
 
     * equipos != null <br>
 
     * No hay dos equipos del mismo país
 
     */
 
    private void verificarInvariante( )
 
    {
 
        assert equipos != null : "La lista de equipos es null";
 
        assert !buscarEquiposConElMismoNombre( ) : "Hay dos equipos con el mismo país";
 
    }
 

 
    /**
 
     * Este método sirve para revisar si hay equipos repetidos dentro del mundial.
 
     * @return Retorna true si hay un equipo que aparece repetido dentro de la lista de equipos. Retorna false en caso contrario.
 
     */
 
    private boolean buscarEquiposConElMismoNombre( )
 
    {
 
        for( int i = 0; i < equipos.size( ); i++ )
 
        {
 
            Equipo e1 = ( Equipo )equipos.get( i );
 
            for( int j = 0; j < equipos.size( ); j++ )
 
            {
 
                if( i != j )
 
                {
 
                    Equipo e2 = ( Equipo )equipos.get( j );
 
                    if( e1.darPais( ).equals( e2.darPais( ) ) )
 
                    {
 
                        return true;
 
                    }
 
                }
 
            }
 
        }
 
        return false;
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Puntos de Extensión
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Método para la extensión 1
 
     * @return respuesta1
 
     */
 
    public String metodo1( )
 
    {
 
        return "Respuesta 1";
 
    }
 

 
    /**
 
     * Método para la extensión2
 
     * @return respuesta2
 
     */
 
    public String metodo2( )
 
    {
 
        return "Respuesta 2";
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PersistenciaException.java,v 1.1 2006/08/28 20:25:13 f-vela Exp $
 
 * Universidad de los Andes (Bogotá - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Licenciado bajo el esquema Academic Free License version 2.1 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
 
 * Ejercicio: n8_mundial
 
 * Autor: Milena Vela - 25-ago-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 */
 

 
package uniandes.cupi2.mundial.mundo;
 

 
/**
 
 * Esta excepción se lanza cuando se presenta un error al leer o escribir el archivo con la información del estado del modelo del mundo. <br>
 
 * El mensaje asociado con la excepción debe describir el problema que se presentó.
 
 */
 
public class PersistenciaException extends Exception
 
{
 
    // -----------------------------------------------------------------
 
    // Constructor
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Construye la excepción con el mensaje que se pasa como parámetro y que describe la causa del problema
 
     * @param causa el mensaje que describe el problema
 
     */
 
    public PersistenciaException( String causa )
 
    {
 
        super( causa );
 
    }
 
}

Mundial

Enunciado

Interfaz

Archivos