Ventas de vehículos

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: DialogoAgregarVehiculo.java,v 1.4 2007/04/05 00:31:11 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 6/12/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 

 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

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

 
import javax.swing.JDialog;
 

 
/**
 
 * Este es el diálogo usado para agregar un vehículo
 
 */
 
public class DialogoAgregarVehiculo extends JDialog
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

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

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

 
    /**
 
     * Es el panel que se usa para introducir los datos del vehículo
 
     */
 
    private PanelAgregarVehiculo panelAgregar;
 

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

 
    /**
 
     * Construye el diálogo e inicializa los componentes
 
     * @param ecv Es una referencia a la ventana principal de la interfaz
 
     */
 
    public DialogoAgregarVehiculo( InterfazVentaVehiculos ecv )
 
    {
 
        super( ecv, true );
 
        ventanaPrincipal = ecv;
 

 
        setLayout( new BorderLayout( ) );
 

 
        panelAgregar = new PanelAgregarVehiculo( this );
 
        add( panelAgregar );
 

 
        setTitle( "Agregar Vehículo" );
 
        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 );
 
    }
 

 
    /**
 
     * Agrega un nuevo vehículo
 
     * @param modeloV El modelo del vehículo - modeloV != null
 
     * @param marcaV La marca del vehículo - marcaV != null
 
     * @param imagenV La ruta a la imagen del vehículo - imagenP != null
 
     * @param tipoV El tipo de vehículo - tipoV es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION}
 
     * @param anioV El año del vehículo - anioV > 0
 
     * @param cilindradaV La cilindrada del vehículo - cilindradaV > 0
 
     * @param ejesV El número de ejes del vehículo - ejesV > 0
 
     * @param valorV El valor del vehículo - valorV > 0
 
     */
 
    public void agregarVehiculo( String modeloV, String marcaV, String imagenV, String tipoV, int anioV, int cilindradaV, int ejesV, int valorV )
 
    {
 
        ventanaPrincipal.agregarVehiculo( this, modeloV, marcaV, imagenV, tipoV, anioV, cilindradaV, ejesV, valorV );
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: InterfazVentaVehiculos.java,v 1.11 2007/04/05 00:55:53 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Insets;
 
import java.awt.Toolkit;
 
import java.io.File;
 
import java.io.FileInputStream;
 
import java.io.FileNotFoundException;
 
import java.io.IOException;
 
import java.util.Properties;
 

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

 
import uniandes.cupi2.ventaVehiculos.mundo.VentaVehiculos;
 
import uniandes.cupi2.ventaVehiculos.mundo.Vehiculo;
 

 
/**
 
 * Es la clase principal de la interfaz
 
 */
 
public class InterfazVentaVehiculos extends JFrame
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Ruta donde se encuentra ubicado el archivo con los datos de los vehículos
 
     */
 
    public static final String ARCHIVO_VEHICULOS = "./data/vehiculos.dat";
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es una referencia a la exposición de vehículo
 
     */
 
    private VentaVehiculos ventaVehiculos;
 

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

 
    /**
 
     * Es el panel donde se muestra la lista de vehículo
 
     */
 
    private PanelListaVehiculos panelLista;
 

 
    /**
 
     * Es el panel donde se muestran los datos de un vehículo
 
     */
 
    private PanelDatosVehiculo panelDatos;
 

 
    /**
 
     * Es el panel donde están los botones para los puntos de extensión
 
     */
 
    private PanelExtension panelExtension;
 

 
    /**
 
     * Es el panel donde están los botones para realizar búsquedas y ordenamiento sobre <br>
 
     * la lista de vehículos
 
     */
 
    private PanelBusquedaOrdenamiento panelBusquedaOrdenamiento;
 

 
    /**
 
     * Es el panel donde están los botones para realizar consultas y operaciones <br>
 
     * sobre la la lista de vehículos
 
     */
 
    private PanelConsultasOperaciones panelConsultasOperaciones;
 

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

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

 
    /**
 
     * Construye la interfaz e inicializa todos sus componentes
 
     */
 
    public InterfazVentaVehiculos( )
 
    {
 
        ventaVehiculos = new VentaVehiculos( );
 

 
        cargarVehiculos( ARCHIVO_VEHICULOS );
 

 
        setLayout( new GridBagLayout( ) );
 

 
        GridBagConstraints gbc = new GridBagConstraints( 1, 1, 1, 1, 1, 0.2, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        panelDatos = new PanelDatosVehiculo( );
 
        add( panelDatos, gbc );
 

 
        gbc = new GridBagConstraints( 0, 1, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        panelLista = new PanelListaVehiculos( this );
 
        add( panelLista, gbc );
 

 
        gbc = new GridBagConstraints( 0, 3, 2, 1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        panelExtension = new PanelExtension( this );
 
        add( panelExtension, gbc );
 

 
        panelBusquedaOrdenamiento = new PanelBusquedaOrdenamiento( this );
 
        gbc = new GridBagConstraints( 0, 2, 1, 1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( panelBusquedaOrdenamiento, gbc );
 

 
        panelConsultasOperaciones = new PanelConsultasOperaciones( this );
 
        gbc = new GridBagConstraints( 1, 2, 1, 1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( panelConsultasOperaciones, gbc );
 

 
        panelImagen = new PanelImagen( );
 
        gbc = new GridBagConstraints( 0, 0, 2, 1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 3, 5, 3, 5 ), 0, 0 );
 
        add( panelImagen, gbc );
 

 
        actualizarLista( );
 

 
        setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
 
        setTitle( "Venta de Vehículos" );
 

 
        setSize( new Dimension( 911, 576 ) );
 
        setResizable( false );
 

 
        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 );
 
    }
 

 
    /**
 
     * Actualiza la lista de vehículos mostrada
 
     */
 
    private void actualizarLista( )
 
    {
 
        panelLista.actualizarLista( ventaVehiculos.darVehiculos( ) );
 
    }
 

 
    /**
 
     * Ordena los vehículos por marca y actualiza la lista
 
     */
 
    public void ordenarPorMarca( )
 
    {
 
        ventaVehiculos.ordenarPorMarca( );
 
        panelDatos.limpiarDatos( );
 
        actualizarLista( );
 
    }
 

 
    /**
 
     * Ordena los vehículos por cilindrada y actualiza la lista
 
     */
 
    public void ordenarPorCilindrada( )
 
    {
 
        ventaVehiculos.ordenarPorCilindrada( );
 
        panelDatos.limpiarDatos( );
 
        actualizarLista( );
 
    }
 

 
    /**
 
     * Ordena los vehículos por año y actualiza la lista
 
     */
 
    public void ordenarPorAnio( )
 
    {
 
        ventaVehiculos.ordenarPorAnio( );
 
        panelDatos.limpiarDatos( );
 
        actualizarLista( );
 
    }
 

 
    /**
 
     * Busca un vehículo usando el modelo y el año y cuando lo encuentra lo selecciona en la lista y muestra sus datos
 
     */
 
    public void buscar( )
 
    {
 
        String nombreBuscado = JOptionPane.showInputDialog( this, "Modelo Buscado" );
 

 
        if( nombreBuscado != null )
 
        {
 
            String anioBuscado = JOptionPane.showInputDialog( this, "Año Buscado" );
 
            if( anioBuscado != null )
 
            {
 
                try
 
                {
 
                    int anio = Integer.parseInt( anioBuscado );
 

 
                    int posicion = ventaVehiculos.buscarVehiculo( nombreBuscado, anio );
 

 
                    actualizarLista( );
 
                    if( posicion != -1 )
 
                    {
 
                        panelLista.seleccionar( posicion );
 
                        Vehiculo p = ( Vehiculo )ventaVehiculos.darVehiculos( ).get( posicion );
 
                        verDatos( p );
 
                    }
 
                    else
 
                    {
 
                        JOptionPane.showMessageDialog( this, "No se encontró el vehículo" );
 
                    }
 
                }
 
                catch( NumberFormatException nfe )
 
                {
 
                    JOptionPane.showMessageDialog( this, "El año debe se un número entero", "Error", JOptionPane.ERROR_MESSAGE );
 
                }
 
            }
 
        }
 
    }
 

 
    /**
 
     * Muestra los datos de un vehículo en el panel correspondiente
 
     * @param vehiculo El vehículo del que se quieren ver los datos - vehiculo != null
 
     */
 
    public void verDatos( Vehiculo vehiculo )
 
    {
 
        panelDatos.mostrarDatos( vehiculo );
 
        pack( );
 
    }
 

 
    /**
 
     * Muestra el diálogo para agregar un vehículo
 
     */
 
    public void mostrarDialogoAgregarVehiculo( )
 
    {
 
        DialogoAgregarVehiculo dav = new DialogoAgregarVehiculo( this );
 
        dav.setVisible( true );
 
    }
 

 
    /**
 
     * Agrega un nuevo vehículo
 
     * @param dialogo Es el diálogo usado para agregar el vehículo
 
     * @param modeloV El modelo del vehículo - modeloV != null
 
     * @param marcaV La marca del vehículo - marcaV != null
 
     * @param imagenV La ruta a la imagen del vehículo - imagenV != null
 
     * @param tipoV El tipo de vehículo - tipoV es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION}
 
     * @param anioV El año del vehículo - anioV > 0
 
     * @param cilindradaV La cilindrada del vehículo - cilindradaV > 0
 
     * @param ejesV El número de ejes del vehículo - ejesV > 0
 
     * @param valor El valor del vehículo - valor > 0
 
     */
 
    public void agregarVehiculo( DialogoAgregarVehiculo dialogo, String modeloV, String marcaV, String imagenV, String tipoV, int anioV, int cilindradaV, int ejesV, int valor )
 
    {
 

 
        boolean agregado = ventaVehiculos.agregarVehiculo( modeloV, marcaV, imagenV, tipoV, anioV, cilindradaV, ejesV, valor );
 

 
        if( agregado )
 
        {
 
            actualizarLista( );
 
            dialogo.dispose( );
 
        }
 
        else
 
        {
 
            JOptionPane.showMessageDialog( this, "El vehículo no pudo ser adicionado", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

 
    /**
 
     * Busca el vehículo más antiguo a la venta y muestra sus datos en el panel información
 
     */
 
    public void buscarMasAntiguo( )
 
    {
 
        int posicion = ventaVehiculos.buscarVehiculoMasAntiguo( );
 

 
        actualizarLista( );
 
        if( posicion != -1 )
 
        {
 
            panelLista.seleccionar( posicion );
 
        }
 
        else
 
        {
 
            JOptionPane.showMessageDialog( this, "Aún no hay vehículos a la venta", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

 
    /**
 
     * Busca el vehículo más potente a la venta y muestra sus datos en el panel información
 
     */
 
    public void buscarMasPotente( )
 
    {
 
        int posicion = ventaVehiculos.buscarVehiculoMasPotente( );
 

 
        actualizarLista( );
 
        if( posicion != -1 )
 
        {
 
            panelLista.seleccionar( posicion );
 
        }
 
        else
 
        {
 
            JOptionPane.showMessageDialog( this, "Aún no hay vehículos a la venta", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

 
    /**
 
     * Busca el vehículo más económico a la venta y muestra sus datos en el panel información
 
     */
 
    public void buscarMasEconomico( )
 
    {
 
        int posicion = ventaVehiculos.buscarVehiculoMasEconomico( );
 

 
        actualizarLista( );
 
        if( posicion != -1 )
 
        {
 
            panelLista.seleccionar( posicion );
 
        }
 
        else
 
        {
 
            JOptionPane.showMessageDialog( this, "Aún no hay vehículos a la venta", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

 
    /**
 
     * Compra el vehículo seleccionado de la lista
 
     */
 
    public void comprarVehiculo( )
 
    {
 
        Vehiculo v = panelLista.darVehiculoSeleccionado( );
 

 
        if( v != null )
 
        {
 
            ventaVehiculos.comprarVehiculo( v.darModelo( ), v.darAnio( ) );
 
            panelDatos.limpiarDatos( );
 
            actualizarLista( );
 
        }
 
        else
 
        {
 
            JOptionPane.showMessageDialog( this, "Debe seleccionar un vehículo", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

 
    /**
 
     * Disminuye el precio de todos los vehículos cuyo valor sea mayor al dado por el usuario
 
     */
 
    public void disminuirPrecio( )
 
    {
 
        String precio = JOptionPane.showInputDialog( this, "Precio para realizar el descuento" );
 

 
        if( precio != null )
 
        {
 
            if( precio.equals( "" ) )
 
            {
 
                JOptionPane.showMessageDialog( this, "El precio debe ser un número entero", "Error", JOptionPane.ERROR_MESSAGE );
 
            }
 
            else
 
            {
 
                try
 
                {
 
                    int valor = Integer.parseInt( precio );
 

 
                    if( valor > 0 )
 
                    {
 
                        int disminuidos = ventaVehiculos.disminuirPrecio( valor );
 

 
                        if( disminuidos > 0 )
 
                        {
 
                            JOptionPane.showMessageDialog( this, "Se disminuyó el precio de " + disminuidos + " vehículos", "Venta de Vehículos", JOptionPane.INFORMATION_MESSAGE );
 
                        }
 
                        else
 
                        {
 
                            JOptionPane.showMessageDialog( this, "No se disminuyó el precio de ningún vehículo", "Venta de Vehículos", JOptionPane.INFORMATION_MESSAGE );
 
                        }
 

 
                        actualizarLista( );
 
                    }
 
                    else
 
                    {
 
                        JOptionPane.showMessageDialog( this, "El precio debe ser un número entero positivo", "Error", JOptionPane.ERROR_MESSAGE );
 
                    }
 
                }
 
                catch( NumberFormatException nfe )
 
                {
 
                    JOptionPane.showMessageDialog( this, "El precio debe ser un número entero", "Error", JOptionPane.ERROR_MESSAGE );
 
                }
 
            }
 

 
        }
 
    }
 

 
    /**
 
     * Carga los carros iniciales de la venta a partir de un archivo de propiedades.
 
     * @param archivo nombre del archivo de propiedades que contiene la información de los vehiculos - archivo!=null
 
     */
 
    private void cargarVehiculos( String archivo )
 
    {
 

 
        try
 
        {
 
            FileInputStream fis = new FileInputStream( new File( archivo ) );
 
            Properties propiedades = new Properties( );
 
            propiedades.load( fis );
 

 
            // Cargar los vehículos
 
            String dato;
 
            String modelo;
 
            String marca;
 
            String imagen;
 
            String tipo;
 
            int anio;
 
            int cilandraje;
 
            int ejes;
 
            int valor;
 
            String aux;
 
            dato = "total.vehiculos";
 
            aux = propiedades.getProperty( dato );
 
            int cantidad = Integer.parseInt( aux );
 

 
            for( int cont = 1; cont <= cantidad; cont++ )
 
            {
 
                // Carga un vehículo
 
                dato = "vehiculo" + cont + ".modelo";
 
                modelo = propiedades.getProperty( dato );
 

 
                dato = "vehiculo" + cont + ".marca";
 
                marca = propiedades.getProperty( dato );
 

 
                dato = "vehiculo" + cont + ".marca";
 
                marca = propiedades.getProperty( dato );
 

 
                dato = "vehiculo" + cont + ".imagen";
 
                imagen = propiedades.getProperty( dato );
 

 
                dato = "vehiculo" + cont + ".tipo";
 
                tipo = propiedades.getProperty( dato );
 

 
                dato = "vehiculo" + cont + ".anio";
 
                aux = propiedades.getProperty( dato );
 
                anio = Integer.parseInt( aux );
 

 
                dato = "vehiculo" + cont + ".cilindrada";
 
                aux = propiedades.getProperty( dato );
 
                cilandraje = Integer.parseInt( aux );
 

 
                dato = "vehiculo" + cont + ".ejes";
 
                aux = propiedades.getProperty( dato );
 
                ejes = Integer.parseInt( aux );
 

 
                dato = "vehiculo" + cont + ".valor";
 
                aux = propiedades.getProperty( dato );
 
                valor = Integer.parseInt( aux );
 

 
                // Sólo se carga el vehiculo si los datos son correctos
 
                if( modelo != null && marca != null && imagen != null && tipo != null && anio > 0 && cilandraje > 0 && ejes > 0 && valor > 0 )
 
                    ventaVehiculos.agregarVehiculo( modelo, marca, imagen, tipo, anio, cilandraje, ejes, valor );
 
                fis.close( );
 
            }
 
        }
 
        catch( FileNotFoundException e )
 
        {
 
            JOptionPane.showMessageDialog( this, "Problemas al cargar la información de los vehículos", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
        catch( IOException e )
 
        {
 
            JOptionPane.showMessageDialog( this, "Problemas al cargar la información de los vehículos", "Error", JOptionPane.ERROR_MESSAGE );
 
        }
 
    }
 

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

 
    /**
 
     * Ejecuta el punto de extensión 1
 
     */
 
    public void reqFuncOpcion1( )
 
    {
 
        String respuesta = ventaVehiculos.metodo1( );
 
        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

 
    /**
 
     * Ejecuta el punto de extensión 2
 
     */
 
    public void reqFuncOpcion2( )
 
    {
 
        String respuesta = ventaVehiculos.metodo2( );
 
        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
 
    }
 

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

 
    /**
 
     * Ejecuta la aplicación
 
     * @param args Son los parámetros de ejecución de la aplicación. No deben usarse.
 
     */
 
    public static void main( String[] args )
 
    {
 
        InterfazVentaVehiculos iec = new InterfazVentaVehiculos( );
 
        iec.setVisible( true );
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelAgregarVehiculo.java,v 1.3 2007/04/05 00:31:11 carl-veg Exp $ 
 
 * Universidad de los Andes (Bogota - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Todos los derechos reservados 2005 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co) 
 
 * Ejercicio: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 

 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

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

 
import javax.swing.JButton;
 
import javax.swing.JComboBox;
 
import javax.swing.JFileChooser;
 
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.ventaVehiculos.mundo.Vehiculo;
 

 
/**
 
 * Este es el panel donde se agregan vehículos
 
 */
 
public class PanelAgregarVehiculo extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    private static final String AGREGAR = "AgregarVehículo";
 

 
    private static final String BUSCAR = "BuscarImagen";
 

 
    private static final String[] TIPOS = new String[]{ Vehiculo.BUS, Vehiculo.AUTOMOVIL, Vehiculo.CAMION, Vehiculo.MOTOCICLETA };
 

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

 
    /**
 
     * Es una referencia al diálogo que contiene el panel
 
     */
 
    private DialogoAgregarVehiculo dialogo;
 

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

 
    /**
 
     * Es el campo para la ruta hasta la imagen del vehículo
 
     */
 
    private JTextField txtImagen;
 

 
    /**
 
     * Es el campo para el modelo del vehículo
 
     */
 
    private JTextField txtModelo;
 

 
    /**
 
     * Es el campo para la marca del vehículo
 
     */
 
    private JTextField txtMarca;
 

 
    /**
 
     * Es el campo para el año del vehículo
 
     */
 
    private JTextField txtAnio;
 

 
    /**
 
     * Es el campo para la cilindrada del vehículo
 
     */
 
    private JTextField txtCilindrada;
 

 
    /**
 
     * Es el campo para el número de ejes del vehículo
 
     */
 
    private JTextField txtEjes;
 

 
    /**
 
     * Es el campo para el valor comercial del vehículo
 
     */
 
    private JTextField txtValor;
 

 
    /**
 
     * El combo para seleccionar el tipo del vehículo
 
     */
 
    private JComboBox cbbTipo;
 

 
    /**
 
     * Es la etiqueta para la imagen del vehículo
 
     */
 
    private JLabel etiquetaImagen;
 

 
    /**
 
     * Es la etiqueta para el modelo del vehículo
 
     */
 
    private JLabel etiquetaModelo;
 

 
    /**
 
     * Es la etiqueta para la marca del vehículo
 
     */
 
    private JLabel etiquetaMarca;
 

 
    /**
 
     * Es la etiqueta donde se muestra el tipo del vehículo
 
     */
 
    private JLabel etiquetaTipo;
 

 
    /**
 
     * Es la etiqueta para el año del vehículo
 
     */
 
    private JLabel etiquetaAnio;
 

 
    /**
 
     * Es la etiqueta para la cilindrada del vehículo
 
     */
 
    private JLabel etiquetaCilindrada;
 

 
    /**
 
     * Es la etiqueta para el número de ejes del vehículo
 
     */
 
    private JLabel etiquetaEjes;
 

 
    /**
 
     * Es la etiqueta para el valor comercial del vehículo
 
     */
 
    private JLabel etiquetaValor;
 

 
    /**
 
     * Es el botón que se usa para agregar un vehículo
 
     */
 
    private JButton botonAgregar;
 

 
    /**
 
     * Es el botón que se usa para examinar el disco buscando la imagen del vehículo
 
     */
 
    private JButton botonExaminar;
 

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

 
    /**
 
     * Construye el panel e inicializa sus componentes
 
     * @param dav Es una referencia al diálogo que contiene el panel- dav!=null
 
     */
 
    public PanelAgregarVehiculo( DialogoAgregarVehiculo dav )
 
    {
 
        dialogo = dav;
 

 
        setLayout( new BorderLayout( ) );
 
        setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Agregar vehículo" ) ) );
 

 
        JPanel panelDatos = new JPanel( new GridLayout( 8, 2 ) );
 

 
        // Modelo
 
        etiquetaModelo = new JLabel( "Modelo: " );
 
        panelDatos.add( etiquetaModelo );
 
        txtModelo = new JTextField( "" );
 
        panelDatos.add( txtModelo );
 

 
        // Marca
 
        etiquetaMarca = new JLabel( "Marca: " );
 
        panelDatos.add( etiquetaMarca );
 
        txtMarca = new JTextField( "" );
 
        panelDatos.add( txtMarca );
 

 
        // Imagen
 
        etiquetaImagen = new JLabel( "Imagen: " );
 
        panelDatos.add( etiquetaImagen );
 
        txtImagen = new JTextField( "" );
 
        botonExaminar = new JButton( "Examinar" );
 
        botonExaminar.setActionCommand( BUSCAR );
 
        botonExaminar.addActionListener( this );
 

 
        JPanel panelImagen = new JPanel( new GridLayout( 1, 2 ) );
 
        panelImagen.add( txtImagen );
 
        panelImagen.add( botonExaminar );
 
        panelDatos.add( panelImagen );
 

 
        // Tipo
 
        etiquetaTipo = new JLabel( "Tipo: " );
 
        panelDatos.add( etiquetaTipo );
 
        cbbTipo = new JComboBox( TIPOS );
 
        panelDatos.add( cbbTipo );
 

 
        // Año
 
        etiquetaAnio = new JLabel( "Año: " );
 
        panelDatos.add( etiquetaAnio );
 
        txtAnio = new JTextField( "" );
 
        panelDatos.add( txtAnio );
 

 
        // Cilindrada
 
        etiquetaCilindrada = new JLabel( "Cilindrada: " );
 
        panelDatos.add( etiquetaCilindrada );
 
        txtCilindrada = new JTextField( "" );
 
        panelDatos.add( txtCilindrada );
 

 
        // Ejes
 
        etiquetaEjes = new JLabel( "Ejes: " );
 
        panelDatos.add( etiquetaEjes );
 
        txtEjes = new JTextField( "" );
 
        panelDatos.add( txtEjes );
 

 
        // Valor
 
        etiquetaValor = new JLabel( "Valor: " );
 
        panelDatos.add( etiquetaValor );
 
        txtValor = new JTextField( "" );
 
        panelDatos.add( txtValor );
 

 
        // Botón agregar
 
        JPanel panelBoton = new JPanel( );
 
        botonAgregar = new JButton( "Agregar Vehículo" );
 
        botonAgregar.setActionCommand( AGREGAR );
 
        botonAgregar.addActionListener( this );
 
        panelBoton.add( botonAgregar );
 

 
        add( panelDatos, BorderLayout.CENTER );
 
        add( panelBoton, BorderLayout.SOUTH );
 
    }
 

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

 
    /**
 
     * Este es el método que se ejecuta cuando se hace click sobre un botón
 
     * @param evento Es el evento del click sobre el botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( AGREGAR.equals( comando ) )
 
        {
 
            try
 
            {
 
                String modelo = txtModelo.getText( );
 
                String marca = txtMarca.getText( );
 
                String imagen = txtImagen.getText( );
 
                String tipo = ( String )cbbTipo.getSelectedItem( );
 
                int anio = Integer.parseInt( txtAnio.getText( ) );
 
                int cilindrada = Integer.parseInt( txtCilindrada.getText( ) );
 
                int ejes = Integer.parseInt( txtEjes.getText( ) );
 
                int valor = Integer.parseInt( txtValor.getText( ) );
 
                dialogo.agregarVehiculo( modelo, marca, imagen, tipo, anio, cilindrada, ejes, valor );
 

 
                txtModelo.setText( "" );
 
                txtMarca.setText( "" );
 
                txtImagen.setText( "" );
 
                txtAnio.setText( "" );
 
            }
 
            catch( NumberFormatException e )
 
            {
 
                JOptionPane.showMessageDialog( this, "El año, la cilindrada, los ejes, y el valor deben ser un número entero positivo", "Error", JOptionPane.ERROR_MESSAGE );
 
            }
 
        }
 
        else if( BUSCAR.equals( comando ) )
 
        {
 
            JFileChooser fc = new JFileChooser( "./data" );
 
            fc.setDialogTitle( "Buscar imagen de vehículo" );
 
            fc.setMultiSelectionEnabled( false );
 

 
            int resultado = fc.showOpenDialog( this );
 
            if( resultado == JFileChooser.APPROVE_OPTION )
 
            {
 
                String imagen = fc.getSelectedFile( ).getAbsolutePath( );
 
                txtImagen.setText( imagen );
 
            }
 
        }
 

 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 * $Id: PanelBusquedaOrdenamiento.java,v 1.5 2007/04/05 00:31:11 carl-veg 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: n7_ventaVehiculos
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Insets;
 
import java.awt.event.ActionEvent;
 
import java.awt.event.ActionListener;
 

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

 
/**
 
 * Panel con las operaciones de búsqueda y ordenamiento sobre la venta de vehículos
 
 */
 
public class PanelBusquedaOrdenamiento extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    private static final String BUSCAR = "Buscar";
 

 
    private static final String ORDENAR_CILINDRADA = "OrdenarCilindrada";
 

 
    private static final String ORDENAR_ANIO = "OrdenarAño";
 

 
    private static final String ORDENAR_MARCA = "OrdenarMarca";
 

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

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

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

 
    /**
 
     * Es el botón para ordenar la lista de vehículos por marca
 
     */
 
    private JButton botonOrdenarMarca;
 

 
    /**
 
     * Es el botón para ordenar la lista de vehículos por cilindrada
 
     */
 
    private JButton botonOrdenarCilindrada;
 

 
    /**
 
     * Es el botón para ordenar la lista de vehículos por año
 
     */
 
    private JButton botonOrdenarAnio;
 

 
    /**
 
     * Es el botón para realizar una búsqueda
 
     */
 
    private JButton botonBuscar;
 

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

 
    /**
 
     * Construye el panel e inicializa todos sus componentes
 
     * @param iec Es una referencia a la clase principal de la interfaz - iec != null
 
     */
 
    public PanelBusquedaOrdenamiento( InterfazVentaVehiculos iec )
 
    {
 
        ventanaPrincipal = iec;
 
        setLayout( new GridBagLayout( ) );
 

 
        setBorder( new TitledBorder( "Búsqueda y Ordenamientos" ) );
 

 
        botonOrdenarMarca = new JButton( "Ordenar por Marca" );
 
        botonOrdenarMarca.setActionCommand( ORDENAR_MARCA );
 
        botonOrdenarMarca.addActionListener( this );
 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridx = 0;
 
        gbc.gridy = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        gbc.insets = new Insets( 3, 3, 3, 3 );
 
        add( botonOrdenarMarca, gbc );
 

 
        botonOrdenarAnio = new JButton( "Ordenar por Año" );
 
        botonOrdenarAnio.setActionCommand( ORDENAR_ANIO );
 
        botonOrdenarAnio.addActionListener( this );
 
        gbc.gridy = 1;
 
        add( botonOrdenarAnio, gbc );
 

 
        botonOrdenarCilindrada = new JButton( "Ordenar por Cilindrada" );
 
        botonOrdenarCilindrada.setActionCommand( ORDENAR_CILINDRADA );
 
        botonOrdenarCilindrada.addActionListener( this );
 
        gbc.gridx = 1;
 
        gbc.gridy = 0;
 
        add( botonOrdenarCilindrada, gbc );
 

 
        botonBuscar = new JButton( "Buscar Vehículo" );
 
        botonBuscar.setActionCommand( BUSCAR );
 
        botonBuscar.addActionListener( this );
 
        gbc.gridy = 1;
 
        add( botonBuscar, gbc );
 

 
    }
 

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

 
    /**
 
     * Ejecuta una acción según el botón que se haya presionado
 
     * @param evento El evento de click sobre un botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( ORDENAR_MARCA.equals( comando ) )
 
        {
 
            ventanaPrincipal.ordenarPorMarca( );
 
        }
 
        else if( ORDENAR_CILINDRADA.equals( comando ) )
 
        {
 
            ventanaPrincipal.ordenarPorCilindrada( );
 
        }
 
        else if( ORDENAR_ANIO.equals( comando ) )
 
        {
 
            ventanaPrincipal.ordenarPorAnio( );
 
        }
 
        else if( BUSCAR.equals( comando ) )
 
        {
 
            ventanaPrincipal.buscar( );
 
        }
 
    }
 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 * $Id: PanelConsultasOperaciones.java,v 1.4 2007/04/05 00:41:15 carl-veg 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: n7_ventaVehiculos
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Insets;
 
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;
 

 
/**
 
 * Panel con diferentes operaciones y consultas sobre la venta de vehículos
 
 */
 
public class PanelConsultasOperaciones extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    private static final String AGREGAR = "AgregarVehículo";
 

 
    private static final String COMPRAR = "ComprarVehiculo";
 

 
    private static final String MAS_ANTIGUO = "MasAntiguo";
 

 
    private static final String MAS_ECONOMICO = "MasEconomico";
 

 
    private static final String MAS_POTENTE = "MasPotente";
 

 
    private static final String DISMINUIR_PRECIO = "DisminuirPrecio";
 

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

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

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

 
    /**
 
     * Es el botón que se usa para agregar un vehículo
 
     */
 
    private JButton botonAgregar;
 

 
    /**
 
     * Es el botón que se usa para buscar el vehículo más antiguo
 
     */
 
    private JButton botonMasAntiguo;
 

 
    /**
 
     * Es el botón que se usa para buscar el vehículo más antiguo
 
     */
 
    private JButton botonMasEconomico;
 

 
    /**
 
     * Es el botón que se usa para buscar el vehículo más potente
 
     */
 
    private JButton botonMasPotente;
 

 
    /**
 
     * Es el botón que se usa para disminuir el precio de los vehículos
 
     */
 
    private JButton botonDisminuirPrecio;
 

 
    /**
 
     * Es el botón que se usa para comprar un vehículo
 
     */
 
    private JButton botonComprar;
 

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

 
    /**
 
     * Construye el panel e inicializa todos sus componentes
 
     * @param iec Es una referencia a la clase principal de la interfaz - iec != null
 
     */
 
    public PanelConsultasOperaciones( InterfazVentaVehiculos iec )
 
    {
 
        ventanaPrincipal = iec;
 
        setLayout( new GridBagLayout( ) );
 

 
        setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Consultas y Operaciones" ) ) );
 

 
        botonAgregar = new JButton( "Agregar Vehículo" );
 
        botonAgregar.setActionCommand( AGREGAR );
 
        botonAgregar.addActionListener( this );
 
        GridBagConstraints gbc = new GridBagConstraints( );
 
        gbc.gridy = 0;
 
        gbc.gridx = 0;
 
        gbc.fill = GridBagConstraints.BOTH;
 
        gbc.insets = new Insets( 0, 0, 5, 5 );
 
        add( botonAgregar, gbc );
 

 
        botonComprar = new JButton( "Comprar Vehículo" );
 
        botonComprar.setActionCommand( COMPRAR );
 
        botonComprar.addActionListener( this );
 
        gbc.gridy = 1;
 
        add( botonComprar, gbc );
 

 
        botonDisminuirPrecio = new JButton( "Disminuir Precio" );
 
        botonDisminuirPrecio.setActionCommand( DISMINUIR_PRECIO );
 
        botonDisminuirPrecio.addActionListener( this );
 
        gbc.gridx = 1;
 
        gbc.gridy = 0;
 
        add( botonDisminuirPrecio, gbc );
 

 
        botonMasAntiguo = new JButton( "Más Antiguo" );
 
        botonMasAntiguo.setActionCommand( MAS_ANTIGUO );
 
        botonMasAntiguo.addActionListener( this );
 
        gbc.gridy = 1;
 
        add( botonMasAntiguo, gbc );
 

 
        botonMasEconomico = new JButton( "Más Económico" );
 
        botonMasEconomico.setActionCommand( MAS_ECONOMICO );
 
        botonMasEconomico.addActionListener( this );
 
        gbc.gridx = 2;
 
        gbc.gridy = 0;
 
        add( botonMasEconomico, gbc );
 

 
        botonMasPotente = new JButton( "Más Potente" );
 
        botonMasPotente.setActionCommand( MAS_POTENTE );
 
        botonMasPotente.addActionListener( this );
 
        gbc.gridy = 1;
 
        add( botonMasPotente, gbc );
 
    }
 

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

 
    /**
 
     * Ejecuta una acción según el botón que se haya presionado
 
     * @param evento El evento de click sobre un botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 

 
        if( AGREGAR.equals( comando ) )
 
        {
 
            ventanaPrincipal.mostrarDialogoAgregarVehiculo( );
 
        }
 
        else if( MAS_ANTIGUO.equals( comando ) )
 
        {
 
            ventanaPrincipal.buscarMasAntiguo( );
 
        }
 
        else if( MAS_ECONOMICO.equals( comando ) )
 
        {
 
            ventanaPrincipal.buscarMasEconomico( );
 
        }
 
        else if( MAS_POTENTE.equals( comando ) )
 
        {
 
            ventanaPrincipal.buscarMasPotente( );
 
        }
 
        else if( COMPRAR.equals( comando ) )
 
        {
 
            ventanaPrincipal.comprarVehiculo( );
 
        }
 
        else if( DISMINUIR_PRECIO.equals( comando ) )
 
        {
 
            ventanaPrincipal.disminuirPrecio( );
 
        }
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelDatosVehiculo.java,v 1.4 2007/04/05 00:31:11 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005
 
 * Autor: Daniel Romero - 17-Nov-2006 
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

 
import java.awt.Color;
 
import java.awt.Dimension;
 
import java.awt.GridBagConstraints;
 
import java.awt.GridBagLayout;
 
import java.awt.Insets;
 

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

 
import uniandes.cupi2.ventaVehiculos.mundo.Vehiculo;
 

 
/**
 
 * Es el panel donde se muestran los datos de un vehículo
 
 */
 
public class PanelDatosVehiculo extends JPanel
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos de la Interfaz
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es la etiqueta donde se muestra la imagen del vehículo
 
     */
 
    private JLabel etiquetaImagen;
 

 
    /**
 
     * Es la etiqueta para el modelo del vehículo
 
     */
 
    private JLabel etiquetaModelo;
 

 
    /**
 
     * Es la etiqueta para la marca del vehículo
 
     */
 
    private JLabel etiquetaMarca;
 

 
    /**
 
     * Es la etiqueta donde se muestra el tipo del vehículo
 
     */
 
    private JLabel etiquetaTipo;
 

 
    /**
 
     * Es la etiqueta para el año del vehículo
 
     */
 
    private JLabel etiquetaAnio;
 

 
    /**
 
     * Es la etiqueta donde se muestra el cilindrada del vehículo
 
     */
 
    private JLabel etiquetaCilindrada;
 

 
    /**
 
     * Es la etiqueta para el número de ejes del vehículo
 
     */
 
    private JLabel etiquetaEjes;
 

 
    /**
 
     * Es la etiqueta para el valor del vehículo
 
     */
 
    private JLabel etiquetaValor;
 

 
    /**
 
     * Es el campo para el modelo del vehículo
 
     */
 
    private JTextField txtModelo;
 

 
    /**
 
     * Es el campo para la marca del vehículo
 
     */
 
    private JTextField txtMarca;
 

 
    /**
 
     * Es el campo para el año del vehículo
 
     */
 
    private JTextField txtAnio;
 

 
    /**
 
     * Es el campo para el cilindrada del vehículo
 
     */
 
    private JTextField txtCilindrada;
 

 
    /**
 
     * Es el campo para el número de ejes del vehículo
 
     */
 
    private JTextField txtEjes;
 

 
    /**
 
     * Es el campo para el tipo del vehículo
 
     */
 
    private JTextField txtTipo;
 

 
    /**
 
     * Es el campo para el valor del vehículo
 
     */
 
    private JTextField txtValor;
 

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

 
    /**
 
     * Construye el panel e inicializa sus componentes
 
     */
 
    public PanelDatosVehiculo( )
 
    {
 
        setLayout( new GridBagLayout( ) );
 
        setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Datos del Vehículo" ) ) );
 

 
        GridBagConstraints gbcE = new GridBagConstraints( 0, 0, 1, 1, 0, 1, GridBagConstraints.SOUTHWEST, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );
 
        GridBagConstraints gbcC = new GridBagConstraints( 1, 0, 1, 1, 0, 0, GridBagConstraints.SOUTH, GridBagConstraints.HORIZONTAL, new Insets( 5, 5, 5, 5 ), 0, 0 );
 

 
        etiquetaModelo = new JLabel( "Modelo: " );
 
        txtModelo = new JTextField( 10 );
 
        txtModelo.setEditable( false );
 
        add( etiquetaModelo, gbcE );
 
        add( txtModelo, gbcC );
 

 
        gbcE.weighty = 0;
 
        gbcE.gridy = 1;
 
        gbcC.gridy = 1;
 
        etiquetaMarca = new JLabel( "Marca: " );
 
        txtMarca = new JTextField( 10 );
 
        txtMarca.setEditable( false );
 
        add( etiquetaMarca, gbcE );
 
        add( txtMarca, gbcC );
 

 
        gbcE.gridy = 2;
 
        gbcC.gridy = 2;
 
        etiquetaTipo = new JLabel( "Tipo: " );
 
        txtTipo = new JTextField( 10 );
 
        txtTipo.setEditable( false );
 
        add( etiquetaTipo, gbcE );
 
        add( txtTipo, gbcC );
 

 
        gbcE.gridy = 3;
 
        gbcC.gridy = 3;
 
        etiquetaAnio = new JLabel( "Año: " );
 
        txtAnio = new JTextField( 10 );
 
        txtAnio.setEditable( false );
 
        add( etiquetaAnio, gbcE );
 
        add( txtAnio, gbcC );
 

 
        gbcE.gridy = 4;
 
        gbcC.gridy = 4;
 
        etiquetaCilindrada = new JLabel( "Cilindrada: " );
 
        txtCilindrada = new JTextField( 10 );
 
        txtCilindrada.setEditable( false );
 
        add( etiquetaCilindrada, gbcE );
 
        add( txtCilindrada, gbcC );
 

 
        gbcE.gridy = 5;
 
        gbcC.gridy = 5;
 
        etiquetaEjes = new JLabel( "Ejes: " );
 
        txtEjes = new JTextField( 10 );
 
        txtEjes.setEditable( false );
 
        add( etiquetaEjes, gbcE );
 
        add( txtEjes, gbcC );
 

 
        gbcE.gridy = 6;
 
        gbcC.gridy = 6;
 
        etiquetaValor = new JLabel( "Valor: " );
 
        txtValor = new JTextField( 10 );
 
        txtValor.setEditable( false );
 
        add( etiquetaValor, gbcE );
 
        add( txtValor, gbcC );
 

 
        GridBagConstraints gbcI = new GridBagConstraints( 2, 0, 1, 7, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );
 

 
        JPanel panelImagen = new JPanel( new GridBagLayout( ) );
 
        etiquetaImagen = new JLabel( );
 
        etiquetaImagen.setBorder( new LineBorder( Color.BLACK, 1 ) );
 
        etiquetaImagen.setMinimumSize( new Dimension( 200, 200 ) );
 
        panelImagen.add( etiquetaImagen );
 
        add( panelImagen, gbcI );
 

 
    }
 

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

 
    /**
 
     * Muestra los datos del vehículo
 
     * @param vehiculo El vehículo del que se quieren mostrar los datos - vehiculo != null
 
     */
 
    public void mostrarDatos( Vehiculo vehiculo )
 
    {
 
        String imagen = vehiculo.darImagen( );
 
        etiquetaImagen.setIcon( new ImageIcon( imagen ) );
 

 
        txtModelo.setText( vehiculo.darModelo( ) );
 
        txtMarca.setText( vehiculo.darMarca( ) );
 
        txtTipo.setText( vehiculo.darTipo( ) );
 
        txtAnio.setText( "" + vehiculo.darAnio( ) );
 
        txtCilindrada.setText( "" + vehiculo.darCilindrada( ) );
 
        txtEjes.setText( "" + vehiculo.darEjes( ) );
 
        txtValor.setText( "" + vehiculo.darValor( ) );
 

 
        validate( );
 
    }
 

 
    /**
 
     * Limpia todos los campos
 
     */
 
    public void limpiarDatos( )
 
    {
 
        etiquetaImagen.setIcon( null );
 
        txtModelo.setText( "" );
 
        txtMarca.setText( "" );
 
        txtTipo.setText( "" );
 
        txtAnio.setText( "" );
 
        txtCilindrada.setText( "" );
 
        txtEjes.setText( "" );
 
        txtValor.setText( "" );
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: PanelExtension.java,v 1.3 2007/04/05 00:41:15 carl-veg Exp $ 
 
 * Universidad de los Andes (Bogota - Colombia)
 
 * Departamento de Ingeniería de Sistemas y Computación 
 
 * Todos los derechos reservados 2005 
 
 *
 
 * Proyecto Cupi2 (http://cupi2.uniandes.edu.co) 
 
 * Ejercicio: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 25/08/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 

 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

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

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

 
/**
 
 * Es el panel que contiene los botones de extensión
 
 */
 
public class PanelExtension extends JPanel implements ActionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * El comando para el botón 1
 
     */
 
    private final String OPCION_1 = "opcion 1";
 

 
    /**
 
     * El comando para el botón 2
 
     */
 
    private final String OPCION_2 = "opcion 2";
 

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

 
    /**
 
     * Es la referencia a la interfaz de la aplicación
 
     */
 
    private InterfazVentaVehiculos ventanaPrincipal;
 

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

 
    /**
 
     * Es el botón 1
 
     */
 
    private JButton botonOpcion1;
 

 
    /**
 
     * Es el botón 2
 
     */
 
    private JButton botonOpcion2;
 

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

 
    /**
 
     * Construye el panel con una referencia a la ventana principal de la aplicación
 
     * @param iec Referencia a la ventana principal - ie!=null
 
     */
 
    public PanelExtension( InterfazVentaVehiculos iec )
 
    {
 
        ventanaPrincipal = iec;
 
        inicializar( );
 
    }
 

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

 
    /**
 
     * Inicializa los componentes del panel
 
     */
 
    private void inicializar( )
 
    {
 
        setBorder( new TitledBorder( "Puntos de Extensión" ) );
 

 
        setLayout( new FlowLayout( ) );
 
        botonOpcion1 = new JButton( "Opción 1" );
 
        botonOpcion1.setActionCommand( OPCION_1 );
 
        botonOpcion1.addActionListener( this );
 

 
        botonOpcion2 = new JButton( "Opción 2" );
 
        botonOpcion2.setActionCommand( OPCION_2 );
 
        botonOpcion2.addActionListener( this );
 

 
        add( botonOpcion1 );
 
        add( botonOpcion2 );
 
    }
 

 
    /**
 
     * Este método se llama cuando se presiona uno de los botones
 
     * @param evento El evento del click en el botón - evento!=null
 
     */
 
    public void actionPerformed( ActionEvent evento )
 
    {
 
        String comando = evento.getActionCommand( );
 
        if( OPCION_1.equals( comando ) )
 
        {
 
            ventanaPrincipal.reqFuncOpcion1( );
 
        }
 
        else if( OPCION_2.equals( comando ) )
 
        {
 
            ventanaPrincipal.reqFuncOpcion2( );
 
        }
 
    }
 

 
}

 
/**
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 * $Id: PanelImagen.java,v 1.2 2006/11/26 18:09:51 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: n7_ventaVehiculos
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 

 
package uniandes.cupi2.ventaVehiculos.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: PanelListaVehiculos.java,v 1.6 2007/04/05 00:41:15 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005
 
 * Autor: Daniel Romero - 17-Nov-2006 
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.interfaz;
 

 
import java.awt.BorderLayout;
 
import java.awt.Color;
 
import java.util.ArrayList;
 

 
import javax.swing.JList;
 
import javax.swing.JPanel;
 
import javax.swing.JScrollPane;
 
import javax.swing.ListSelectionModel;
 
import javax.swing.border.CompoundBorder;
 
import javax.swing.border.EmptyBorder;
 
import javax.swing.border.LineBorder;
 
import javax.swing.border.TitledBorder;
 
import javax.swing.event.ListSelectionEvent;
 
import javax.swing.event.ListSelectionListener;
 

 
import uniandes.cupi2.ventaVehiculos.mundo.Vehiculo;
 

 
/**
 
 * Es el panel donde se muestra la lista de vehículos
 
 */
 
public class PanelListaVehiculos extends JPanel implements ListSelectionListener
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

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

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

 
    /**
 
     * Es la lista que se muestra
 
     */
 
    private JList listaVehiculos;
 

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

 
    /**
 
     * Construye el panel e inicializa todos sus componentes
 
     * @param iec Es una referencia a la clase principal de la interfaz - iec != null
 
     */
 
    public PanelListaVehiculos( InterfazVentaVehiculos iec )
 
    {
 
        ventanaPrincipal = iec;
 
        setLayout( new BorderLayout( ) );
 

 
        JPanel panelListaYBotones = new JPanel( );
 
        panelListaYBotones.setLayout( new BorderLayout( ) );
 
        panelListaYBotones.setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Vehículos a la Venta" ) ) );
 

 
        listaVehiculos = new JList( );
 
        listaVehiculos.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
 
        listaVehiculos.addListSelectionListener( this );
 

 
        JScrollPane scroll = new JScrollPane( );
 
        scroll.setHorizontalScrollBarPolicy( JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
 
        scroll.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
 
        scroll.setBorder( new CompoundBorder( new EmptyBorder( 3, 3, 3, 3 ), new LineBorder( Color.BLACK, 1 ) ) );
 
        scroll.getViewport( ).add( listaVehiculos );
 

 
        panelListaYBotones.add( scroll, BorderLayout.CENTER );
 
        add( panelListaYBotones, BorderLayout.CENTER );
 
    }
 

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

 
    /**
 
     * Actualiza la lista de vehículos que se está mostrando
 
     * @param listaActualizadaVehiculos Es una lista con los vehículos que deben mostrarse
 
     */
 
    public void actualizarLista( ArrayList listaActualizadaVehiculos )
 
    {
 
        listaVehiculos.setListData( listaActualizadaVehiculos.toArray( ) );
 
        listaVehiculos.setSelectedIndex( 0 );
 

 
    }
 

 
    /**
 
     * Selecciona un elemento de la lista
 
     * @param seleccionado La posición del elemento que se debe seleccionar
 
     */
 
    public void seleccionar( int seleccionado )
 
    {
 
        listaVehiculos.setSelectedIndex( seleccionado );
 
        listaVehiculos.ensureIndexIsVisible( seleccionado );
 
    }
 

 
    /**
 
     * Informa si hay algún índice seleccionado en la lista de vehiculos.
 
     * @return true si hay un ítem seleccionado, false de lo contrario
 
     */
 
    public boolean haySeleccionado( )
 
    {
 
        return !listaVehiculos.isSelectionEmpty( );
 
    }
 

 
    /**
 
     * Retorna el vehiculo seleccionado de la lista
 
     * @return Se retornó el vehiculo seleccionado de la lista. Si no hay vehículo seleccionado se retornó null
 
     */
 
    public Vehiculo darVehiculoSeleccionado( )
 
    {
 
        Vehiculo vSeleccionado = null;
 

 
        if( listaVehiculos.getSelectedValue( ) != null )
 
        {
 
            vSeleccionado = ( Vehiculo )listaVehiculos.getSelectedValue( );
 
        }
 

 
        return vSeleccionado;
 
    }
 

 
    /**
 
     * Cambia la información del aspirante que se esta mostrando de acuerdo al nuevo aspirante seleccionado
 
     * @param e El evento de cambio del ítem seleccionado en la lista. evento!=null
 
     */
 
    public void valueChanged( ListSelectionEvent e )
 
    {
 
        if( listaVehiculos.getSelectedValue( ) != null )
 
        {
 
            Vehiculo vehiculo = ( Vehiculo )listaVehiculos.getSelectedValue( );
 
            ventanaPrincipal.verDatos( vehiculo );
 
        }
 

 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: Vehiculo.java,v 1.5 2007/04/10 22:56:32 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.mundo;
 

 
/**
 
 * Es la clase que representa a un vehículo <br>
 
 * <b>inv: </b> <br>
 
 * modelo != null <br>
 
 * imagen != null <br>
 
 * marca != null <br>
 
 * anio > 0 <br>
 
 * tipo es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION} <br>
 
 * cilindrada > 0 <br>
 
 * ejes > 1 <br>
 
 * valor>0
 
 */
 
public class Vehiculo
 
{
 
    // -----------------------------------------------------------------
 
    // Constantes
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Indica que el vehículo es un bus
 
     */
 
    public static final String BUS = "Bus";
 

 
    /**
 
     * Indica que el vehículo es un automóvil
 
     */
 
    public static final String AUTOMOVIL = "Automóvil";
 

 
    /**
 
     * Indica que el vehículo es una motocicleta
 
     */
 
    public static final String MOTOCICLETA = "Moto";
 

 
    /**
 
     * Indica que el vehículo es un camión
 
     */
 
    public static final String CAMION = "Camión";
 

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

 
    /**
 
     * El modelo del vehículo
 
     */
 
    private String modelo;
 

 
    /**
 
     * La marca del vehículo
 
     */
 
    private String marca;
 

 
    /**
 
     * La ruta hasta la imagen del vehículo
 
     */
 
    private String imagen;
 

 
    /**
 
     * El tipo de vehículo
 
     */
 
    private String tipo;
 

 
    /**
 
     * El año de puesta en venta del modelo
 
     */
 
    private int anio;
 

 
    /**
 
     * El cilindrada del vehículo
 
     */
 
    private int cilindrada;
 

 
    /**
 
     * El número de Ejes
 
     */
 
    private int ejes;
 

 
    /**
 
     * El valor comercial del vehículo
 
     */
 
    private int valor;
 

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

 
    /**
 
     * Construye un nuevo vehículo con los parámetros indicados
 
     * @param modeloV El nombre del modelo - modeloV != null
 
     * @param marcaV La marca del vehículo - marcaV != null
 
     * @param imagenV La ruta a la imagen del vehículo - imagenP != null
 
     * @param tipoV El tipo del vehículo - tipoV es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION}
 
     * @param anioV El año del vehículo - anioV > 0
 
     * @param cilindradaV La cilindrada del vehículo - cilindradaV > 0
 
     * @param ejesV El número de ejes del vehículo - ejesV > 0
 
     * @param valorV El valor del vehículo - valor > 0
 
     */
 
    public Vehiculo( String modeloV, String marcaV, String imagenV, String tipoV, int anioV, int cilindradaV, int ejesV, int valorV )
 
    {
 
        modelo = modeloV;
 
        marca = marcaV;
 
        imagen = imagenV;
 
        tipo = tipoV;
 
        anio = anioV;
 
        cilindrada = cilindradaV;
 
        ejes = ejesV;
 
        valor = valorV;
 

 
        verificarInvariante( );
 
    }
 

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

 
    /**
 
     * Retorna el modelo del vehículo
 
     * @return modelo
 
     */
 
    public String darModelo( )
 
    {
 
        return modelo;
 
    }
 

 
    /**
 
     * Retorna la marca del vehículo
 
     * @return marca
 
     */
 
    public String darMarca( )
 
    {
 
        return marca;
 
    }
 

 
    /**
 
     * Retorna la ruta a la imagen del vehículo
 
     * @return imagen
 
     */
 
    public String darImagen( )
 
    {
 
        return imagen;
 
    }
 

 
    /**
 
     * Retorna el tipo del vehículo
 
     * @return tipo
 
     */
 
    public String darTipo( )
 
    {
 
        return tipo;
 
    }
 

 
    /**
 
     * Retorna el año del vehículo
 
     * @return anio
 
     */
 
    public int darAnio( )
 
    {
 
        return anio;
 
    }
 

 
    /**
 
     * Retorna la cilindrada del vehículo
 
     * @return cilindrada
 
     */
 
    public int darCilindrada( )
 
    {
 
        return cilindrada;
 
    }
 

 
    /**
 
     * Retorna el número de ejes del vehículo
 
     * @return ejes
 
     */
 
    public int darEjes( )
 
    {
 
        return ejes;
 
    }
 

 
    /**
 
     * Retorna el valor del vehículo
 
     * @return valor
 
     */
 
    public int darValor( )
 
    {
 
        return valor;
 
    }
 

 
    /**
 
     * Compara dos vehículos según su cilindrada
 
     * @param v El vehículo contra el que se está comparando - e!=null
 
     * @return Retorna 0 si los vehículos tienen la misma cilindrada. <br>
 
     *         Retorna -1 si el vehículo v tiene una valor "MAYOR" para la cilindrada. <br>
 
     *         Retorna 1 si el vehículo v tiene una valor "MENOR" para la cilindrada. <br>
 
     */
 
    public int compararPorCilindrada( Vehiculo v )
 
    {
 
        int resultado = ( cilindrada == v.darCilindrada( ) ) ? 0 : ( ( cilindrada > v.darCilindrada( ) ) ? 1 : -1 );
 
        return resultado;
 
    }
 

 
    /**
 
     * Compara dos vehículos según su marca
 
     * @param v El vehículo contra el que se está comparando - e!=null
 
     * @return Retorna 0 si los vehículos tienen la misma marca. <br>
 
     *         Retorna -1 si el vehículo v tiene una valor "MAYOR" para la marca. <br>
 
     *         Retorna 1 si el vehículo v tiene una valor "MENOR" para la marca. <br>
 
     */
 
    public int compararPorMarca( Vehiculo v )
 
    {
 
        return marca.toLowerCase( ).compareTo( v.darMarca( ).toLowerCase( ) );
 
    }
 

 
    /**
 
     * Compara dos vehículos según su año
 
     * @param v El vehículo contra el que se está comparando - e!=null
 
     * @return Retorna 0 si los vehículos son del mismo año. <br>
 
     *         Retorna -1 si el vehículo v es de un año posterior. <br>
 
     *         Retorna 1 si el vehículo v es de un año anterior. <br>
 
     */
 
    public int compararPorAnio( Vehiculo v )
 
    {
 
        int resultado = ( anio == v.darAnio( ) ) ? 0 : ( ( anio > v.darAnio( ) ) ? 1 : -1 );
 
        return resultado;
 
    }
 

 
    /**
 
     * Compara dos vehículos según su valor
 
     * @param v El vehículo contra el que se está comparando - v!=null
 
     * @return Retorna 0 si los vehículos tienen el mismo valor. <br>
 
     *         Retorna -1 si el vehículo v tiene una valor "MAYOR" para el valor. <br>
 
     *         Retorna 1 si el vehículo v tiene una valor "MENOR" para el valor. <br>
 
     */
 
    public int compararPorValor( Vehiculo v )
 
    {
 
        int resultado = ( valor == v.darValor( ) ) ? 0 : ( ( valor > v.darValor( ) ) ? 1 : -1 );
 
        return resultado;
 
    }
 

 
    /**
 
     * Cambia el valor del vehículo
 
     * @param nValor Nuevo valor del vehículo
 
     */
 
    public void cambiarValor( int nValor )
 
    {
 
        valor = nValor;
 
    }
 

 
    /**
 
     * Retorna una cadena con el nombre y la marca del vehículo
 
     * @return <marca> <modelo> (<anio>);
 
     */
 
    public String toString( )
 
    {
 
        return marca + " " + modelo + " (" + anio + ")";
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Invariante
 
    // -----------------------------------------------------------------
 
    /**
 
     * Verifica el invariante de la clase <br>
 
     * <b>inv: </b> <br>
 
     * modelo != null <br>
 
     * imagen != null <br>
 
     * marca != null <br>
 
     * anio > 0 <br>
 
     * tipo es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION} <br>
 
     * cilindrada > 0 <br>
 
     * ejes > 1 <br>
 
     * valor > 0
 
     */
 
    private void verificarInvariante( )
 
    {
 
        assert ( tipo.equals( BUS ) || tipo.equals( AUTOMOVIL ) || tipo.equals( MOTOCICLETA ) || tipo.equals( CAMION )  ) : "El tipo debe ser uno de los valores válidos";
 
        assert ( anio > 0 ) : "El año no puede ser 0";
 
        assert ( imagen != null ) : "La imagen no puede ser null";
 
        assert ( modelo != null ) : "El modelo no puede ser null";
 
        assert ( marca != null ) : "La marca no puede ser null";
 
        assert ( cilindrada > 0 ) : "La cilindrada no puede ser 0";
 
        assert ( ejes > 1 ) : "El número de ejes debe ser mayor a 1";
 
        assert ( valor > 0 ) : "El vehículo debe tener un valor mayor a 0";
 
    }
 
}

 
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * $Id: VentaVehiculos.java,v 1.8 2007/04/05 00:55:53 carl-veg 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: n7_ventaVehiculos 
 
 * Autor: Mario Sánchez - 06/12/2005 
 
 * Autor: Daniel Romero - 17-Nov-2006
 
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 
 */
 
package uniandes.cupi2.ventaVehiculos.mundo;
 

 
import java.util.ArrayList;
 

 
/**
 
 * Es la clase que se encarga de manejar, organizar, cargar y salvar los vehículos <br>
 
 * <b>inv </b> <br>
 
 * vehículos != null y no hay dos vehículos con el mismo nombre
 
 */
 
public class VentaVehiculos
 
{
 
    // -----------------------------------------------------------------
 
    // Atributos
 
    // -----------------------------------------------------------------
 

 
    /**
 
     * Es la lista que contiene todos los vehículos
 
     */
 
    private ArrayList vehiculos;
 

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

 
    /**
 
     * Construye un nuevo manejador de vehículos vacío.
 
     */
 
    public VentaVehiculos( )
 
    {
 
        vehiculos = new ArrayList( );
 

 
    }
 

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

 
    /**
 
     * Retorna una lista de vehículos. La lista que se retorna no es la misma que la almacenada en esta clase, <br>
 
     * pero si tiene el mismo orden.
 
     * @return lista de vehículos
 
     */
 
    public ArrayList darVehiculos( )
 
    {
 
        ArrayList copiaLista = new ArrayList( vehiculos );
 
        return copiaLista;
 
    }
 

 
    /**
 
     * Organiza la lista de vehículos por marca usando el algoritmo de burbuja <br>
 
     * <b>post: </b>La lista de vehículos está ordenada por marca
 
     */
 
    public void ordenarPorMarca( )
 
    {
 
        int inicial;
 

 
        for( inicial = 0; inicial < vehiculos.size( ); inicial++ )
 
        {
 
            for( int i = vehiculos.size( ) - 1; i > inicial; i-- )
 
            {
 
                Vehiculo p2 = ( Vehiculo )vehiculos.get( i );
 
                Vehiculo p1 = ( Vehiculo )vehiculos.get( i - 1 );
 

 
                if( p1.compararPorMarca( p2 ) > 0 )
 
                {
 
                    vehiculos.set( i, p1 );
 
                    vehiculos.set( i - 1, p2 );
 
                }
 
            }
 
        }
 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Organiza la lista de vehículos por cilindrada usando el algoritmo de inserción <br>
 
     * <b>post: </b>La lista de vehículos está ordenada por cilindrada
 
     */
 
    public void ordenarPorCilindrada( )
 
    {
 
        int inicial;
 

 
        // En cada paso se sabe que:
 
        // 1. Las posiciones antes de vehículos[inicial] están ordenadas
 
        // En cada paso lo que se hace es encontrar en qué posición entre vehículos[0] y vehículos[inicial] debería
 
        // estar el vehículo que en este momento se encuentra en vehículos[inicial]
 

 
        for( inicial = 1; inicial < vehiculos.size( ); inicial++ )
 
        {
 
            Vehiculo insertado = ( Vehiculo )vehiculos.get( inicial );
 

 
            boolean termine = false;
 
            int i = inicial - 1;
 

 
            while( !termine )
 
            {
 
                // Si encuentra una cilindrada mayor, entonces hay que intercambiarlos
 
                Vehiculo vehículoPosicion = ( Vehiculo )vehiculos.get( i );
 

 
                if( vehículoPosicion.compararPorCilindrada( insertado ) > 0 )
 
                {
 
                    vehiculos.set( i, insertado );
 
                    vehiculos.set( i + 1, vehículoPosicion );
 
                    i--;
 
                }
 
                // Si se encuentra un cilindrada igual o menor entonces ya se encontró la posición
 
                else
 
                {
 
                    termine = true;
 
                }
 

 
                // Si ya se llegó al principio de la lista no hay nada más que hacer
 
                if( i < 0 )
 
                {
 
                    termine = true;
 
                }
 
            }
 
        }
 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Organiza la lista de vehículos por el año usando el algoritmo de selección <br>
 
     * <b>post: </b>La lista de vehículos está ordenada por año
 
     */
 
    public void ordenarPorAnio( )
 
    {
 
        int inicial;
 

 
        // En cada paso se sabe que:
 
        // 1. Todos los valores antes de vehículos[inicial] están ordenados
 
        // 2. No hay ningún valor después de vehículos[inicial-1] que sea menor que vehículos[inicial-1]
 
        // En cada paso se busca el menor entre vehículos[inicial] y vehículos[final] y se ubica en vehículos[inicial]
 

 
        for( inicial = 0; inicial < vehiculos.size( ); inicial++ )
 
        {
 
            int posicionMenor = inicial;
 
            Vehiculo vehículoMenor = ( Vehiculo )vehiculos.get( inicial );
 

 
            for( int i = inicial + 1; i < vehiculos.size( ); i++ )
 
            {
 
                Vehiculo vehículoPosicion = ( Vehiculo )vehiculos.get( i );
 

 
                // El vehículo de la posición actual es menor que el menor encontrado hasta el momento
 
                if( vehículoPosicion.compararPorAnio( vehículoMenor ) < 0 )
 
                {
 
                    vehículoMenor = vehículoPosicion;
 
                    posicionMenor = i;
 
                }
 
            }
 

 
            if( posicionMenor != inicial )
 
            {
 
                Vehiculo temp = ( Vehiculo )vehiculos.get( inicial );
 
                vehiculos.set( inicial, vehículoMenor );
 
                vehiculos.set( posicionMenor, temp );
 
            }
 

 
        }
 
        verificarInvariante( );
 
    }
 

 
    /**
 
     * Busca un vehículo según su modelo y retorna la posición en la que se encuentra. <br>
 
     * @param modelo El modelo del vehículo buscado - modelo != null
 
     * @param anio El año del vehículo buscado - anio > 0
 
     * @return Retorna la posición donde se encuentra un vehículo con el modelo y el año dado. Si no se encuentra ningún vehículo con ese modelo y año retorna -1.
 
     */
 
    public int buscarVehiculo( String modelo, int anio )
 
    {
 
        int posicion = -1;
 
        boolean termine = false;
 

 
        for( int i = 0; i < vehiculos.size( ) && !termine; i++ )
 
        {
 
            Vehiculo vehiculoPosicion = ( Vehiculo )vehiculos.get( i );
 
            String modeloVehiculo = vehiculoPosicion.darModelo( );
 

 
            // Los modelos son iguales
 
            if( modeloVehiculo.equals( modelo ) && vehiculoPosicion.darAnio( ) == anio )
 
            {
 
                posicion = i;
 
                termine = true;
 
            }
 
        }
 

 
        return posicion;
 
    }
 

 
    /**
 
     * Agrega un nuevo vehículo
 
     * @param modeloV El modelo del vehículo - modeloV != null
 
     * @param marcaV La marca del vehículo - marcaV != null
 
     * @param imagenP La ruta a la imagen del vehículo - imagenP != null
 
     * @param tipoV El tipo de vehículo - tipoV es uno de {BUS, AUTMOVIL, MOTOCICLETA, CAMION}
 
     * @param anioV El año del vehículo - anioV > 0
 
     * @param cilindradaV La cilindrada del vehículo - cilindradaV > 0
 
     * @param ejesV El número de ejes del vehículo - ejesV > 0
 
     * @param valor El valor del vehículo - valor > 0
 
     * @return Se retornó true si el vehículo fue agregado o false en caso de que ya existiera un vehículo con el mismo modelo y año
 
     */
 
    public boolean agregarVehiculo( String modeloV, String marcaV, String imagenP, String tipoV, int anioV, int cilindradaV, int ejesV, int valor )
 
    {
 
        boolean agregado = false;
 
        int vehículoBuscado = buscarVehiculo( modeloV, anioV );
 
        if( vehículoBuscado == -1 )
 
        {
 
            Vehiculo nuevovehículo = new Vehiculo( modeloV, marcaV, imagenP, tipoV, anioV, cilindradaV, ejesV, valor );
 
            vehiculos.add( nuevovehículo );
 
            agregado = true;
 
            verificarInvariante( );
 
        }
 

 
        return agregado;
 

 
    }
 

 
    /**
 
     * Elimina de la lista el vehículo especificado
 
     * @param modelo Modelo del vehículo - modelo!=null
 
     * @param anio Año del vehículo - anio>0
 
     * @return Se retornó true si el vehículo fue comprado o false en caso contrario
 
     */
 
    public boolean comprarVehiculo( String modelo, int anio )
 
    {
 
        boolean comprado = false;
 

 
        for( int cont = 0; cont < vehiculos.size( ) && !comprado; cont++ )
 
        {
 
            Vehiculo v = ( Vehiculo )vehiculos.get( cont );
 

 
            if( v.darAnio( ) == anio && v.darModelo( ).equalsIgnoreCase( modelo ) )
 
            {
 
                vehiculos.remove( cont );
 
                comprado = true;
 
            }
 
        }
 

 
        return comprado;
 
    }
 

 
    /**
 
     * Busca el vehículo más antiguo de todos
 
     * @return Se retornó la posición donde se encuentra el vehículo más antiguo. Si no hay vehículos a la venta se retornó -1
 
     */
 
    public int buscarVehiculoMasAntiguo( )
 
    {
 
        int posicion = -1;
 

 
        if( vehiculos.size( ) > 0 )
 
        {
 
            Vehiculo vMasAntiguo = ( Vehiculo )vehiculos.get( 0 );
 
            posicion = 0;
 
            for( int i = 1; i < vehiculos.size( ); i++ )
 
            {
 
                Vehiculo vPosicion = ( Vehiculo )vehiculos.get( i );
 

 
                if( vMasAntiguo.compararPorAnio( vPosicion ) == 1 )
 
                {
 
                    posicion = i;
 
                    vMasAntiguo = vPosicion;
 
                }
 
            }
 
        }
 
        return posicion;
 
    }
 

 
    /**
 
     * Busca el vehículo más económico de todos
 
     * @return Se retornó la posición donde se encuentra el vehículo más económico. Si no hay vehículos a la venta se retornó -1
 
     */
 
    public int buscarVehiculoMasEconomico( )
 
    {
 
        int posicion = -1;
 

 
        if( vehiculos.size( ) > 0 )
 
        {
 
            Vehiculo vMasEconomico = ( Vehiculo )vehiculos.get( 0 );
 
            posicion = 0;
 
            for( int i = 1; i < vehiculos.size( ); i++ )
 
            {
 
                Vehiculo vPosicion = ( Vehiculo )vehiculos.get( i );
 

 
                if( vMasEconomico.compararPorValor( vPosicion ) == 1 )
 
                {
 
                    posicion = i;
 
                    vMasEconomico = vPosicion;
 
                }
 
            }
 
        }
 
        return posicion;
 
    }
 

 
    /**
 
     * Busca el vehículo más potente (con mayor cilindrada) de todos
 
     * @return Se retornó la posición donde se encuentra el vehículo más nuevo. Si no hay vehículos a la venta se retornó -1
 
     */
 
    public int buscarVehiculoMasPotente( )
 
    {
 
        int posicion = -1;
 

 
        if( vehiculos.size( ) > 0 )
 
        {
 
            Vehiculo vMasPotente = ( Vehiculo )vehiculos.get( 0 );
 
            posicion = 0;
 
            for( int i = 1; i < vehiculos.size( ); i++ )
 
            {
 
                Vehiculo vPosicion = ( Vehiculo )vehiculos.get( i );
 

 
                if( vMasPotente.compararPorCilindrada( vPosicion ) == -1 )
 
                {
 
                    posicion = i;
 
                    vMasPotente = vPosicion;
 
                }
 
            }
 
        }
 
        return posicion;
 
    }
 

 
    /**
 
     * Disminuye en un 10% el precio de todos los vehículos cuyo precio es mayor al valor especificado. <br>
 
     * El precio de un vehículo sólo se disminuye si su valor no queda en cero.
 
     * @param valor El valor para realizar la disminución de precios. valor>0
 
     * @return La cantidad de vehículos a los que se les disminuyó el precio
 
     */
 
    public int disminuirPrecio( int valor )
 
    {
 
        int disminuidos = 0;
 

 
        for( int cont = 0; cont < vehiculos.size( ); cont++ )
 
        {
 
            Vehiculo v = ( Vehiculo )vehiculos.get( cont );
 

 
            if( v.darValor( ) > valor )
 
            {
 
                int nValor = ( int ) ( v.darValor( ) * 0.9 );
 

 
                if( nValor > 0 )
 
                {
 
                    v.cambiarValor( nValor );
 
                    disminuidos++;
 
                }
 
            }
 
        }
 
        return disminuidos;
 
    }
 

 
    // -----------------------------------------------------------------
 
    // Invariante
 
    // -----------------------------------------------------------------
 
    /**
 
     * Verifica el invariante de la clase
 
     * 
 
     */
 
    private void verificarInvariante( )
 
    {
 
        assert ( vehiculos != null ) : "La lista de vehículos no debe ser null";
 
        assert ( !buscarVehiculosModeloYAnioRepetido( ) ) : "Hay dos vehículos del mismo modelo y año";
 
    }
 

 
    /**
 
     * Verifica si hay dos vehículos con el mismo modelo y el mismo año
 
     * @return Retorna true si hay dos vehículos con el mismo nombre y año; retorna false en caso contrario.
 
     */
 
    private boolean buscarVehiculosModeloYAnioRepetido( )
 
    {
 
        for( int i = 0; i < vehiculos.size( ); i++ )
 
        {
 
            Vehiculo pi = ( Vehiculo )vehiculos.get( i );
 
            for( int j = 0; j < vehiculos.size( ); j++ )
 
            {
 
                if( i != j )
 
                {
 
                    Vehiculo pj = ( Vehiculo )vehiculos.get( j );
 
                    if( pj.darModelo( ).equals( pi.darModelo( ) ) && pj.darAnio( ) == pi.darAnio( ) )
 
                    {
 
                        return true;
 
                    }
 
                }
 
            }
 
        }
 
        return false;
 
    }
 

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

 
    /**
 
     * Ejecuta el punto de extensión 1
 
     * @return respuesta 1
 
     */
 
    public String metodo1( )
 
    {
 
        return "respuesta1";
 
    }
 

 
    /**
 
     * Ejecuta el punto de extensión 2
 
     * @return respuesta 2
 
     */
 
    public String metodo2( )
 
    {
 
        return "respuesta2";
 
    }
 
}

Ventas de vehículos

Enunciado

Demo

Archivos