
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: BarraMenu.java 78 2006-03-30 14:31:19Z da-romer $ 

 * 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: n10_partitura 

 * Autor: Mario Sánchez - 27/09/2005 

 * Modificada por: Daniel Romero - 22/03/2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.interfaz;



import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;



import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.KeyStroke;



/**

 * Esta es la barra que contiene los menús de la aplicación

 */

public class BarraMenu extends JMenuBar implements ActionListener

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    private static final String NUEVO = "Nuevo";



    private static final String ABRIR = "Abrir";



    private static final String GUARDAR = "Guardar";



    private static final String GUARDAR_COMO = "GuardarComo";



    private static final String SALIR = "Salir";



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Es una referencia a la clase principal de la interfaz

     */

    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Atributos de la Interfaz

    // -----------------------------------------------------------------



    /**

     * El menú Archivo

     */

    private JMenu menuArchivo;



    /**

     * La opción Nuevo del menú Archivo

     */

    private JMenuItem itemNuevo;



    /**

     * La opción Abrir del menú Archivo

     */

    private JMenuItem itemAbrir;



    /**

     * La opción Salvar del menú Archivo

     */

    private JMenuItem itemSalvar;



    /**

     * La opción Salvar Como del menú Archivo

     */

    private JMenuItem itemSalvarComo;



    /**

     * La opción Salir del menú Archivo

     */

    private JMenuItem itemSalir;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye la barra de menú

     * @param ip Es una referencia a la clase principal de la interfaz

     */

    public BarraMenu( InterfazPartitura ip )

    {

        principal = ip;



        menuArchivo = new JMenu( "Archivo" );

        add( menuArchivo );



        itemNuevo = new JMenuItem( "Nueva Partitura" );

        itemNuevo.setActionCommand( NUEVO );

        itemNuevo.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_N, ActionEvent.CTRL_MASK ) );

        itemNuevo.addActionListener( this );

        menuArchivo.add( itemNuevo );



        itemAbrir = new JMenuItem( "Abrir Partitura" );

        itemAbrir.setActionCommand( ABRIR );

        itemAbrir.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_A, ActionEvent.CTRL_MASK ) );

        itemAbrir.addActionListener( this );

        menuArchivo.add( itemAbrir );



        itemSalvar = new JMenuItem( "Guardar Partirura" );

        itemSalvar.setActionCommand( GUARDAR );

        itemSalvar.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_S, ActionEvent.CTRL_MASK ) );

        itemSalvar.addActionListener( this );

        menuArchivo.add( itemSalvar );



        itemSalvarComo = new JMenuItem( "Guardar Partitura Como" );

        itemSalvarComo.setActionCommand( GUARDAR_COMO );

        itemSalvarComo.addActionListener( this );

        menuArchivo.add( itemSalvarComo );



        menuArchivo.addSeparator( );



        itemSalir = new JMenuItem( "Salir" );

        itemSalir.setActionCommand( SALIR );

        itemSalir.addActionListener( this );

        menuArchivo.add( itemSalir );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Ejecuta la acción que corresponde a la opción del menú que fue seleccionada

     * @param evento Es el evento de seleccionar una opción del menú

     */

    public void actionPerformed( ActionEvent evento )

    {

        String comando = evento.getActionCommand( );



        if( NUEVO.equals( comando ) )

        {

            principal.limpiarPartitura( );

        }

        else if( ABRIR.equals( comando ) )

        {

            principal.abrir( );

        }

        else if( GUARDAR.equals( comando ) )

        {

            principal.salvar( );

        }

        else if( GUARDAR_COMO.equals( comando ) )

        {

            principal.salvarComo( );

        }

        else if( SALIR.equals( comando ) )

        {

            principal.dispose( );

        }

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: DialogoInformacionNota.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura  

 * Autor: Daniel Romero - 22/03/2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.interfaz;



import java.awt.Color;

import java.awt.Dimension;

import java.awt.Toolkit;



import javax.swing.JDialog;



/**

 * Es el diálogo para modificar la información de la nota (clase, tipo y color)

 */

public class DialogoInformacionNota extends JDialog

{

    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Es una referencia a la clase principal de la interfaz

     */

    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Atributos de la Intefaz

    // -----------------------------------------------------------------



    /**

     * El panel donde se modifica la información de la nota

     */

    private PanelModificarInformacionNota panelModificar;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye el diálogo para modificar la información de una nota

     * @param ip Es una referencia a la clase principal de la interfaz

     * @param clase Es el título que se escribirá sobre la partitura

     * @param tipo Es el tipo de la nota

     * @param nombre Es el nombre de la nota

     * @param color Es el color de la nota

     * @param pos La posición de la nota a la que se le va a cambiar la información

     * @param titulo Es el titulo del diálogo

     * 

     */

    public DialogoInformacionNota( InterfazPartitura ip, String clase, String tipo, String nombre, Color color, int pos, String titulo )

    {

        super( ip, titulo, true );



        principal = ip;



        // Construir el panel y mostrar el diálogo

        panelModificar = new PanelModificarInformacionNota( this, pos );

        getContentPane( ).add( panelModificar );

        panelModificar.cambiarInformacion( clase, tipo, nombre, color );



        setSize( 200, 200 );

        setResizable( false );

        centrarVentana( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Cambia la información de la nota correspondiente a la posición especificada

     * @param clase La clase de la nota (rendonda, blanca, negra, corchea, semicorchea)

     * @param tipo El tipo de la nota (normal o sostenido)

     * @param color El color de la nota

     * @param posicion La posición de la nota a ser modificada

     * @param nombre El nombre de la nota (do, re mi, fa sol, la, si, do2)

     */

    public void cambiarInformacionNota( String clase, String tipo, Color color, int posicion, String nombre )

    {

        principal.cambiarInformacionNota( clase, tipo, color, posicion, nombre );

        setVisible( false );

        dispose( );

    }



    /**

     * Centra la ventana en la pantalla

     */

    private void centrarVentana( )

    {

        Dimension pantalla = Toolkit.getDefaultToolkit( ).getScreenSize( );

        setLocation( ( int ) ( pantalla.getWidth( ) / 2 - getWidth( ) / 2 ), ( int ) ( pantalla.getHeight( ) / 2 - getHeight( ) / 2 ) );

    }

}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: DialogoTituloPartitura.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura 

 * Autor: Mario Sánchez - 27/09/2005 

 * Modificado por: Daniel Romero - 23/03/2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.interfaz;



import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.GraphicsEnvironment;

import java.awt.Toolkit;

import java.util.ArrayList;



import javax.swing.JDialog;



/**

 * Es el diálogo para modificar el texto, fuente y color del título de la partitura

 */

public class DialogoTituloPartitura extends JDialog

{

    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Es una referencia a la clase principal de la interfaz

     */

    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Atributos de la Intefaz

    // -----------------------------------------------------------------



    /**

     * El panel donde se modifica el título, la fuente y el color usados en la partitura

     */

    private PanelModificarTitulo panelModificar;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye el diálogo para modificar el título y la fuente de una partitura

     * @param principal Es una referencia a la clase principal de la interfaz

     * @param texto Es el título que se escribirá sobre la partitura

     * @param fuente Es la fuente que se usará para el título de la partitura

     * @param nombre Es el nombre del dialogo

     * @param color Es el color del título de la partitura

     * 

     */

    public DialogoTituloPartitura( InterfazPartitura ip, String texto, Font fuente, String nombre, Color color )

    {

        super( ip, nombre, true );



        principal = ip;



        // Averiguar cuales son las fuentes disponibles en el sistema

        String[] nombresFuentes = GraphicsEnvironment.getLocalGraphicsEnvironment( ).getAvailableFontFamilyNames( );



        ArrayList listaFuentes = new ArrayList( );

        for( int i = 0; i < nombresFuentes.length; i++ )

        {

            listaFuentes.add( nombresFuentes[ i ] );

        }



        // Construir el panel y mostrar el diálogo

        panelModificar = new PanelModificarTitulo( this, listaFuentes );

        getContentPane( ).add( panelModificar );

        panelModificar.cambiarTexto( texto, fuente, color );



        setSize( 400, 180 );

        centrarVentana( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Cambia el titulo mostrada

     * @param titulo El título de la partitura

     * @param fuente La fuente con que se va a escribir el título

     */

    public void cambiarTitulo( String titulo, Font fuente, Color color )

    {

        principal.cambiarTituloPartitura( titulo, fuente, color );

        setVisible( false );

        dispose( );

    }



    /**

     * Centra la ventana en la pantalla

     */

    private void centrarVentana( )

    {

        Dimension pantalla = Toolkit.getDefaultToolkit( ).getScreenSize( );

        setLocation( ( int ) ( pantalla.getWidth( ) / 2 - getWidth( ) / 2 ), ( int ) ( pantalla.getHeight( ) / 2 - getHeight( ) / 2 ) );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: InterfazPartitura.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero - Marzo 23, 2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.interfaz;



import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;



import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JOptionPane;



import uniandes.cupi2.partitura.mundo.FormatoInvalidoExcepcion;

import uniandes.cupi2.partitura.mundo.INota;

import uniandes.cupi2.partitura.mundo.Nota;

import uniandes.cupi2.partitura.mundo.Partitura;



/**

 * Ventana principal de la aplicación

 */

public class InterfazPartitura extends JFrame

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    public final static int LIBRE = 1;



    public final static int GUIADA = 0;



    public static final int COMPONER = 2;



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Representa una partitura que tiene cargada una canción

     */

    private Partitura partitura;



    /**

     * Es el archivo donde se está salvando actualmente la partitura

     */

    private String archivo;



    /**

     * reproduce notas en la interfaz

     */

    private ReproductorNota reproductor;



    // -----------------------------------------------------------------

    // Atributos de la interfaz

    // -----------------------------------------------------------------



    /**

     * Representa el panel que muestra la partitura

     */

    private PanelPartitura panelPartitura;



    /**

     * Representa el panel que muestra el teclado y realiza acciones de tocar notas

     */

    private PanelTeclado panelTeclado;



    /**

     * Representa el panel de acciones

     */

    private PanelOpciones panelOpciones;



    /**

     * Es la ruta hasta el último directorio de donde se cargó o salvó un archivo

     */

    private String ultimoDirectorio;



    /**

     * Es la barra del menú

     */

    private BarraMenu barra;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye la ventana principal de la aplicación y ubica los elementos que la<br>

     * componen en un orden adecuado

     */

    public InterfazPartitura( )

    {

        partitura = new Partitura( );

        panelTeclado = new PanelTeclado( this );

        panelPartitura = new PanelPartitura( this );

        panelOpciones = new PanelOpciones( this );



        getContentPane( ).setLayout( new BorderLayout( ) );

        getContentPane( ).add( panelOpciones, BorderLayout.SOUTH );

        getContentPane( ).add( panelTeclado, BorderLayout.CENTER );

        getContentPane( ).add( panelPartitura, BorderLayout.NORTH );



        setTitle( "PartituraMusical" );

        setSize( 1030, 700 );

        setResizable( true );

        setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );



        barra = new BarraMenu( this );

        setJMenuBar( barra );

        ultimoDirectorio = "./data";



        reproductor = new ReproductorNota( this );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Coloca la posición de la nota marcada de la partitura en -1 y <br>

     * hace que la partitura se pinte de nuevo

     */

    public void reiniciarPartitura( )

    {

        cambiarPosicionNotaMarcada( -1 );

        panelPartitura.actualizar( );

    }



    /**

     * Borra las notas y título de la partitura y hace que se pinte de nuevo

     */

    public void limpiarPartitura( )

    {

        partitura.eliminarNotas( );

        partitura.cambiarTitulo( "" );

        partitura.cambiarNotaMarcada( -1 );

        panelPartitura.actualizar( );

        validate( );

    }



    /**

     * Cambia el tipo de práctica con el modo especificado.

     * @param modo - Indica el modo de practica (LIBRE, PARTITURA ó GUIADA)

     */

    public void cambiarModo( int modo )

    {

        panelTeclado.cambiarModo( modo );



        if( panelTeclado.darModo( ) != COMPONER )

        {

            panelTeclado.desbloquearTeclado( );

        }

        else if( partitura.darNotas( ).size( ) == Partitura.NUM_MAX_NOTAS )

        {

            panelTeclado.bloquearTeclado( );

        }

    }



    /**

     * Da una lista con las notas de la partitura cargada en el mundo

     * @return Arraylist con las notas

     */

    public ArrayList darNotas( )

    {

        return partitura.darNotas( );

    }



    /**

     * Le pide al usuario un archivo para abrir y lo carga en el panel de la partitura <br>

     * <b>post: </b>Se cargó una partitura que estaba guardada

     */

    public void abrir( )

    {

        boolean abrir = pedirConfirmacion( );

        if( abrir )

        {

            JFileChooser fc = new JFileChooser( ultimoDirectorio );

            fc.setDialogTitle( "Abrir Partirura" );

            fc.setFileSelectionMode( JFileChooser.FILES_ONLY );

            fc.setMultiSelectionEnabled( false );



            int resultado = fc.showOpenDialog( this );



            if( resultado == JFileChooser.APPROVE_OPTION )

            {

                File seleccionado = fc.getSelectedFile( );

                ultimoDirectorio = seleccionado.getParentFile( ).getAbsolutePath( );



                try

                {



                    partitura.abrir( seleccionado.getAbsolutePath( ) );

                    panelPartitura.actualizar( );

                }

                catch( FormatoInvalidoExcepcion e )

                {

                    JOptionPane.showMessageDialog( this, "Hubo problemas cargando el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );

                }

                catch( IOException e )

                {

                    JOptionPane.showMessageDialog( this, "Hubo problemas cargando el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );

                }

            }

        }

    }



    /**

     * Este método solicita una confirmación para realizar una acción que haría que el trabajo se perdiera. <br>

     * Presenta una ventana con las opciones "Si","No" y "Cancelar". <br>

     * Si se selecciona "Si", entonces se salva el archivo actual. <br>

     * Si se selecciona "No", el archivo no se salva y se retorna true <br>

     * Si se selecciona "Cancelar", el archivo no se salva pero se retorna false para que la acción no se realice.

     * @return Retorna true si la acción se debe realizar; retorna false en caso contrario.

     */

    private boolean pedirConfirmacion( )

    {

        boolean cerrar = true;



        int respuesta = JOptionPane.showConfirmDialog( this, "Desea guardar el archivo actual antes de continuar?", "Salvar", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE );



        if( respuesta == JOptionPane.YES_OPTION )

        {

            salvar( );

        }



        else if( respuesta == JOptionPane.NO_OPTION )

        {

            // No hace nada

        }



        else if( respuesta == JOptionPane.CANCEL_OPTION )

        {

            cerrar = false;

        }



        return cerrar;

    }



    /**

     * Salva la partitura en el archivo del que se había cargado o donde se había salvado la última vez. <br>

     * Si se trata de una partitura nueva y no se ha salvado entonces se pregunta el nombre del archivo donde se salvará. <br>

     * <b>post: </b> Se salvó la partitura.

     */

    public void salvar( )

    {

        String nombreArchivo = partitura.darNombreArchivo( );

        if( nombreArchivo == null )

        {

            salvarComo( );

        }

        else

        {

            try

            {

                partitura.salvar( );

            }

            catch( IOException e )

            {

                JOptionPane.showMessageDialog( this, "Hubo problemas salvando el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );

            }

        }

    }



    /**

     * Salva la partitura en un archivo del cual se le pregunta el nombre al usuario. <br>

     * <b>post: </b> Se salvó la partitura en un archivo que se le preguntó al usuario.

     */

    public void salvarComo( )

    {

        JFileChooser fc = new JFileChooser( ultimoDirectorio );

        fc.setDialogTitle( "Guardar como" );

        fc.setFileSelectionMode( JFileChooser.FILES_ONLY );

        fc.setMultiSelectionEnabled( false );



        boolean termine = false;



        int resultado = fc.showSaveDialog( this );



        while( !termine )

        {

            if( resultado == JFileChooser.APPROVE_OPTION )

            {

                File seleccionado = fc.getSelectedFile( );

                ultimoDirectorio = seleccionado.getParentFile( ).getAbsolutePath( );



                int respuesta = JOptionPane.YES_OPTION;



                // Si el archivo ya existe hay que pedir confirmación para

                // sobrescribirlo

                if( seleccionado.exists( ) )

                {

                    respuesta = JOptionPane.showConfirmDialog( this, "�Desea sobrescribir el archivo seleccionado?", "Sobrescribir", JOptionPane.YES_NO_OPTION, JOptionPane.INFORMATION_MESSAGE );

                }



                // Si la respuesta fue positiva (o si no fue necesario hacer la

                // pregunta) se graba el archivo

                if( respuesta == JOptionPane.YES_OPTION )

                {

                    try

                    {

                        partitura.salvar( seleccionado.getAbsolutePath( ) );

                        termine = true;

                    }

                    catch( IOException e )

                    {

                        JOptionPane.showMessageDialog( this, "Hubo problemas guardando el archivo:\n" + e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );

                    }

                }

                else

                {

                    resultado = fc.showSaveDialog( this );

                }

            }

            else

            {

                termine = true;

            }

        }

    }



    /**

     * Muestra la ventana de texto utilizada para modificar el título de la partitura cuando se hace doble clic.

     */

    public void mostrarVentanaTitulo( )

    {

        String titulo = "";

        String nomDialogo;

        Font fuente = partitura.darFuenteTitulo( );



        titulo = partitura.darTitulo( );

        nomDialogo = "Titulo Partitura";

        Color colorT = partitura.darColorTitulo( );



        DialogoTituloPartitura dt = new DialogoTituloPartitura( this, titulo, fuente, nomDialogo, colorT );

        dt.setVisible( true );



    }



    /**

     * Muestra la ventana para modificar la información de la nota

     * @param pos La posición de la nota a ser modificada

     * 

     */

    public void mostrarVentanaInformacionNota( int pos )

    {

        String clase;

        String tipo;

        String nombre;

        Color color;

        String nomDialogo;

        INota nota;



        nota = partitura.darNota( pos );

        clase = nota.darClase( );

        tipo = nota.darTipo( );

        nombre = nota.darNombre( );

        color = nota.darColor( );

        nomDialogo = "Información Nota";



        DialogoInformacionNota di = new DialogoInformacionNota( this, clase, tipo, nombre, color, pos, nomDialogo );

        di.setVisible( true );



    }



    /**

     * Cambia el título de la partitura. <br>

     * <b>post: </b> Se modificó el título de la partitura.

     * @param titulo El titulo que va a tener la partitura

     * @param fuente La fuente del título de la partitura

     * @param color El color que va a tener el título de la partitura

     */

    public void cambiarTituloPartitura( String titulo, Font fuente, Color color )

    {

        if( partitura != null )

        {

            partitura.cambiarFuenteTitulo( fuente );

            partitura.cambiarTitulo( titulo );

            partitura.cambiarColorTitulo( color );



            repintarPartitura( );

        }

    }



    /**

     * Elimina la nota en la posición especificada

     * @param posNota Posición de la nota a ser eliminada

     */

    public void eliminarNota( int posNota )

    {



        partitura.eliminarNota( posNota );



        if( posNota == partitura.darPosicionNotaMarcada( ) )

        {

            cambiarPosicionNotaMarcada( posNota - 1 );

        }



        repintarPartitura( );



        if( panelTeclado.darModo( ) == COMPONER && partitura.darNotas( ).size( ) < Partitura.NUM_MAX_NOTAS )

        {

            panelTeclado.desbloquearTeclado( );

        }



    }



    /**

     * Cambia la información de la nota correspondiente a la posición especificada

     * @param clase La clase de la nota (redonda, blanca, negra, corchea, semicorchea)

     * @param tipo El tipo de la nota (normal o sostenido)

     * @param color El color de la nota

     * @param posicion La posición de la nota a ser modificada

     * @param nombre El nombre de la nota (do, re mi, fa sol, la, si, do2)

     */

    public void cambiarInformacionNota( String clase, String tipo, Color color, int posicion, String nombre )

    {

        partitura.cambiarInformacionNota( clase, tipo, color, posicion, nombre );

        repintarPartitura( );



    }



    /**

     * Cambia la nota marcada en la partitura

     * @param pos Posición de la nota a ser marcada

     */

    public void cambiarPosicionNotaMarcada( int pos )

    {



        partitura.cambiarNotaMarcada( pos );

    }



    /**

     * Pinta de nuevo la partitura

     */

    public void repintarPartitura( )

    {

        panelPartitura.actualizar( );



    }



    /**

     * Verifica que la nota tocada sea la correcta

     * @param nota La nota a ser verificada

     * @param posicionActual La posición de la nota

     * @return Indica si la nota tocada coincide con la nota que se debe tocar en la posición actual de la partitura

     */

    public boolean verificarNota( INota nota, int posicionActual )

    {



        return partitura.verificarNota( nota, posicionActual );

    }



    /**

     * Adiciona la nota tocada por el usuario a la partitura

     * @param nota Nota a ser adicionada

     */

    public void adicionarNotaPartitura( INota nota )

    {

        partitura.adicionarNota( nota );



        // Si la partitura está en modo composición y número máximo de notas de composición se ha alcanzado se bloquea el teclado

        if( panelTeclado.darModo( ) == COMPONER && partitura.darNotas( ).size( ) == Partitura.NUM_MAX_NOTAS )

        {

            panelTeclado.bloquearTeclado( );

        }

    }



    /**

     * Toca la nota dada especificada. El método realiza lo siguiente: <br>

     * 1. Verifica que la posición de la nota marcada no sea mayor o igual al número máximo de notas de la partitura. Si esto no se cumple se pone la posición de la nota

     * marcada en -1. <br>

     * 2. Si el modo es guiada, obtiene la información de la nota marcada (clase y color)e incrementa la posición de la nota marcada se incrementa en 1. <br>

     * 3. Si el modo es componer obtiene la clase de nota ingresada por el usuario. <br>

     * 4. Obtiene la nota a ser tocada. <br>

     * 5. Toca la nota 6. Si el modo es componer, adiciona la nota tocada a la partitura

     * @param nombreNota Nombre de la nota que oprimió el usuario en el teclado

     * 

     */

    public void tocarNota( String nombreNota )

    {

        INota nota = null;

        INota aux = null;

        String claseNota = "Negra";

        Color color = Color.BLACK;

        int posNota = -1;

        int posicionActual = darPosicionNotaMarcada( );



        if( posicionActual + 1 >= darNotas( ).size( ) )

        {

            posicionActual = -1;

            cambiarPosicionNotaMarcada( posicionActual );

        }



        if( panelTeclado.darModo( ) == GUIADA )

        {

            aux = ( INota )darNotas( ).get( posicionActual + 1 );

            claseNota = aux.darClase( );

            color = aux.darColor( );

            posNota = posicionActual + 1;

        }

        else if( panelTeclado.darModo( ) == COMPONER )

        {

            claseNota = darClaseNotaSeleccionada( );

        }



        nota = obtenerNota( nombreNota, claseNota, color );

        tocarSonido( nota, posNota );



        if( panelTeclado.darModo( ) == InterfazPartitura.COMPONER )

        {

            adicionarNotaPartitura( nota );

        }



    }



    /**

     * Obtiene la nota basándose en la información proporcionada

     * @param nombreNota El nombre de la nota

     * @param claseNota La clase a la que pertenece la nota

     * @param color El color de la nota

     * @return La nota construida a partir de la información dada

     */

    private INota obtenerNota( String nombreNota, String claseNota, Color color )

    {

        INota nota = null;

        if( nombreNota.endsWith( "#" ) )

        {

            nombreNota = nombreNota.substring( 0, nombreNota.length( ) - 1 );

            nota = partitura.crearNota( claseNota, nombreNota, Nota.SOSTENIDO, color );

        }

        else

        {

            nota = partitura.crearNota( claseNota, nombreNota, Nota.NORMAL, color );

        }

        return nota;

    }



    /**

     * Toca la melodía de la partitura

     */

    public void tocarMelodia( )

    {

        // se ubica en practica libre

        cambiarModo( GUIADA );

        reiniciarPartitura( );

        ArrayList notas = darNotas( );



        int contador = 1;

        // principal.repintarPartitura( principal.darNotas( ), posicionActual );

        while( contador < notas.size( ) + 1 )

        {

            INota nota1 = ( INota )notas.get( contador - 1 );



            try

            {



                tocarSonido( nota1, contador - 1 );

            }

            catch( Exception e )

            {

                JOptionPane.showMessageDialog( this, "Error al tocar la nota" + e.getMessage( ) );

                e.printStackTrace( );

            }



            contador++;

        }



        cambiarPosicionNotaMarcada( -1 );



    }



    /**

     * Toca un sonido dado el nombre, el tipo, y su número de representación en el reproductor. <br>

     * En modo de práctica el sonido de la nota sólo se reproduce si se toca la nota adecuada según <br>

     * la partitura; si la nota estaba equivocada se toca una corneta. <br>

     * Si se está en modo libre siempre se toca la nota seleccionada.

     * @param nota - La nota a ser tocada

     * @param posNota - Es la posición de la nota que se va a tocar

     */

    private void tocarSonido( INota nota, int posNota )

    {

        String nombre = nota.darNombre( );

        String tipo = nota.darTipo( );

        double duracion = nota.darDuracion( );

        int notaReproducir = darNumeroNota( nombre, tipo );

        // si se esta en modo partitura se realizan las verificaciones correspondientes



        if( panelTeclado.darModo( ) == InterfazPartitura.GUIADA )

        {

            // verificación de la nota

            boolean notaCorrecta = verificarNota( nota, darPosicionNotaMarcada( ) + 1 );



            // si la nota esta correcta se toca la nota y se avanza una posición en la partitura

            if( notaCorrecta )

            {

                // Tocar Nota



                cambiarPosicionNotaMarcada( posNota );

                reproductor.tocarNota( notaReproducir, 0, duracion, posNota );

            }

            else

            {

                // si la nota no esta correcta toca la nota 30 en el canal 15 del syntetizador (corneta)

                reproductor.tocarNota( 30, 15, 2, -1 );

            }



        }

        else

        {

            // Tocar Nota si se esta en modo libre

            reproductor.tocarNota( notaReproducir, 0, duracion, -1 );

        }



    }



    /**

     * Retorna el número que representa una nota tocada en el reproductor. <br>

     * En este caso va de 60 a 72 donde 60 es Do y 72 es el Do de la siguiente octava.

     * @param nombre El nombre de la nota que se tocó

     * @param tipo Indica si la nota fue normal o sostenida.

     * @return Retorna el número de la nota para el reproductor

     */

    private int darNumeroNota( String nombre, String tipo )

    {

        if( nombre.equals( Nota.DO ) )

        {

            if( tipo.equals( Nota.NORMAL ) )

            {

                return 60;

            }

            else if( tipo.equals( Nota.SOSTENIDO ) )

            {

                return 61;

            }

        }

        else if( nombre.equals( Nota.RE ) )

        {

            if( tipo.equals( Nota.NORMAL ) )

            {

                return 62;

            }

            else if( tipo.equals( Nota.SOSTENIDO ) )

            {

                return 63;

            }

        }

        else if( nombre.equals( Nota.MI ) )

        {

            return 64;

        }

        else if( nombre.equals( Nota.FA ) )

        {

            if( tipo.equals( Nota.NORMAL ) )

            {

                return 65;

            }

            else if( tipo.equals( Nota.SOSTENIDO ) )

            {

                return 66;

            }

        }

        else if( nombre.equals( Nota.SOL ) )

        {

            if( tipo.equals( Nota.NORMAL ) )

            {

                return 67;

            }

            else if( tipo.equals( Nota.SOSTENIDO ) )

            {

                return 68;

            }

        }

        else if( nombre.equals( Nota.LA ) )

        {

            if( tipo.equals( Nota.NORMAL ) )

            {

                return 69;

            }

            else if( tipo.equals( Nota.SOSTENIDO ) )

            {

                return 70;

            }

        }

        else if( nombre.equals( Nota.SI ) )

        {

            return 71;

        }

        else if( nombre.equals( Nota.DO2 ) )

        {

            return 72;

        }

        return 0;

    }



    /**

     * Retorna la clase de nota seleccionada en el panel de opciones

     * @return La clase de nota seleccionada

     */

    public String darClaseNotaSeleccionada( )

    {



        return panelOpciones.darClaseNota( );

    }



    /**

     * Retorna la posición de la nota que se encuentra marcada actualmente

     * @return Posición de la nota marcada actualmente

     */

    public int darPosicionNotaMarcada( )

    {



        return partitura.darPosicionNotaMarcada( );

    }



    /**

     * Manda a pintar la partitura

     * @param g El área donde se va a pintar

     */

    public void pintarPartitura( Graphics2D g )

    {

        partitura.pintarPartitura( g );

    }



    /**

     * Busca la nota donde se hizo el clic del ratón

     * @param x Coordenada x del clic del ratón

     * @param y Coordenada y del clic del ratón

     * @return La posición de la nota que "recibió" el clic. -1 si ninguna

     */

    public int buscarNota( int x, int y )

    {

        return partitura.buscarNota( x, y );

    }



    // -----------------------------------------------------------------

    // Puntos de Extensión

    // -----------------------------------------------------------------



    /**

     * Ejecuta la extensión 1

     */

    public void reqFuncOpcion1( )

    {

        String respuesta = partitura.metodo1( );

        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );

    }



    /**

     * Ejecuta la extensión 2

     */

    public void reqFuncOpcion2( )

    {

        String respuesta = partitura.metodo2( );

        JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );



    }



    // -----------------------------------------------------------------

    // Ejecución

    // -----------------------------------------------------------------



    /**

     * Inicializa la aplicación

     * @param args Son los parámetros de ejecución de la aplicación. No se deben usar.

     */

    public static void main( String[] args )

    {

        InterfazPartitura i = new InterfazPartitura( );

        i.setVisible( true );

    }

}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: PanelModificarInformacionNota.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero - Marzo 23, 2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.interfaz;



import java.awt.Color;

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 javax.swing.JButton;

import javax.swing.JColorChooser;

import javax.swing.JComboBox;

import javax.swing.JLabel;

import javax.swing.JPanel;



/**

 * Panel donde se muestra la información para modificar una nota

 */

public class PanelModificarInformacionNota extends JPanel implements ActionListener

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    private static final String CLASE = "Clase";



    private static final String TIPO = "Tipo";



    private static final String COLOR = "Color";



    private static final String NOMBRE = "Nombre";



    private static final String CANCELAR = "Cancelar";



    private static final String OK = "Ok";



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------

    /**

     * Posición de la nota a ser modificada

     */

    private int posicionNota;



    // -----------------------------------------------------------------

    // Atributos de la Interfaz

    // -----------------------------------------------------------------



    /**

     * Es una referencia al diálogo que contiene este panel

     */

    private DialogoInformacionNota dialogo;



    /**

     * Es el comboBox para seleccionar la clase

     */

    private JComboBox cbbClase;



    /**

     * Es el comboBox para seleccionar el tipo

     */

    private JComboBox cbbTipo;



    /**

     * Es el comboBox para seleccionar el nombre

     */

    private JComboBox cbbNombre;



    /**

     * Es el botón para seleccionar el color

     */

    private JButton botonColor;



    /**

     * Etiqueta con el nombre "Clase"

     */

    private JLabel etiquetaClase;



    /**

     * Etiqueta con el nombre "Tipo"

     */

    private JLabel etiquetaTipo;



    /**

     * Etiqueta con el nombre "Color"

     */

    private JLabel etiquetaColor;



    /**

     * Etiqueta con el nombre "Color"

     */

    private JLabel etiquetaNombre;



    /**

     * Es el botón Ok

     */

    private JButton botonOk;



    /**

     * Es el botón Cancelar

     */

    private JButton botonCancelar;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Inicializa el panel

     * @param din Es una referencia al diálogo en el que se encuentra el panel

     * @param posNota La posición de la nota que se va a modificar

     */

    public PanelModificarInformacionNota( DialogoInformacionNota din, int posNota )

    {

        dialogo = din;



        posicionNota = posNota;



        // setLayout( new GridLayout(5,2) );

        setLayout( new GridBagLayout( ) );



        // Inicializa los componentes

        inicializarComponentes( );



        // Ubica los componentes

        ubicarComponentes( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Ubica los componentes en sus posiciones <br>

     * <b>pre: </b>Los componentes ya están inicializados

     */

    private void ubicarComponentes( )

    {



        GridBagConstraints gbc = new GridBagConstraints( 0, 1, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( etiquetaClase, gbc );

        gbc = new GridBagConstraints( 1, 1, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( cbbClase, gbc );

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

        add( etiquetaTipo, gbc );

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

        add( cbbTipo, gbc );



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

        add( etiquetaNombre, gbc );

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

        add( cbbNombre, gbc );

        gbc = new GridBagConstraints( 0, 4, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( etiquetaColor, gbc );

        gbc = new GridBagConstraints( 1, 4, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( botonColor, gbc );



        JPanel panelBotones = new JPanel( );

        panelBotones.setLayout( new GridLayout( 1, 2 ) );

        panelBotones.add( botonOk );

        panelBotones.add( botonCancelar );



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

        add( panelBotones, gbc );

    }



    /**

     * Inicializa los componentes

     * @param fuentes Es una lista con los nombres de las fuentes instaladas en el sistema

     */

    private void inicializarComponentes( )

    {

        cbbClase = new JComboBox( );

        cbbClase.setActionCommand( CLASE );

        cbbClase.addItem( "Redonda" );

        cbbClase.addItem( "Blanca" );

        cbbClase.addItem( "Negra" );

        cbbClase.addItem( "Corchea" );

        cbbClase.addItem( "Semicorchea" );

        cbbClase.addActionListener( this );



        cbbTipo = new JComboBox( );

        cbbTipo.setActionCommand( TIPO );

        cbbTipo.addItem( "Normal" );

        cbbTipo.addItem( "Sostenido" );



        cbbNombre = new JComboBox( );

        cbbNombre.setActionCommand( NOMBRE );

        cbbNombre.addItem( "do" );

        cbbNombre.addItem( "re" );

        cbbNombre.addItem( "mi" );

        cbbNombre.addItem( "fa" );

        cbbNombre.addItem( "sol" );

        cbbNombre.addItem( "la" );

        cbbNombre.addItem( "si" );

        cbbNombre.addItem( "do2" );



        botonColor = new JButton( );

        botonColor.setActionCommand( COLOR );

        botonColor.addActionListener( this );



        botonCancelar = new JButton( );

        botonCancelar.setActionCommand( CANCELAR );

        botonCancelar.setText( "Cancelar" );

        botonCancelar.addActionListener( this );



        botonOk = new JButton( );

        botonOk.setActionCommand( OK );

        botonOk.setText( "OK" );

        botonOk.addActionListener( this );



        etiquetaClase = new JLabel( "Clase" );



        etiquetaTipo = new JLabel( "Tipo" );



        etiquetaColor = new JLabel( "Color" );



        etiquetaNombre = new JLabel( "Nombre" );



    }



    /**

     * Cambia el texto mostrado y actualiza los combo box para mostrar la fuente indicada

     * @param texto El texto que se va a mostrar

     * @param fuente La fuente actual del texto

     * @param nombre El nombre de la nota

     * @param color El color de la nota

     */

    public void cambiarInformacion( String clase, String tipo, String nombre, Color color )

    {

        cbbClase.setSelectedItem( clase );



        cbbTipo.setSelectedItem( tipo );



        cbbNombre.setSelectedItem( nombre.toLowerCase( ) );



        botonColor.setBackground( color );

    }



    /**

     * Es el método que ejecuta la acción que se debe ejecutar cuando se hace click sobre un botón o cuando cambia la opción seleccionada en uno de los comboBox

     * @param evento Es el evento del click sobre un botón

     */

    public void actionPerformed( ActionEvent evento )

    {

        String comando = evento.getActionCommand( );



        if( OK.equals( comando ) )

        {

            String clase = ( String )cbbClase.getSelectedItem( );

            String tipo = ( String )cbbTipo.getSelectedItem( );

            Color color = botonColor.getBackground( );

            String nombre = ( ( String )cbbNombre.getSelectedItem( ) ).toUpperCase( );



            dialogo.cambiarInformacionNota( clase, tipo, color, posicionNota, nombre );

        }

        else if( CANCELAR.equals( comando ) )

        {

            dialogo.dispose( );

        }

        else if( COLOR.equals( comando ) )

        {

            Color colorT = JColorChooser.showDialog( this, "Color del fondo", botonColor.getBackground( ) );

            botonColor.setBackground( colorT );

        }



    }

}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: PanelModificarTitulo.java 516 2006-10-23 05:06:15Z da-romer $ 

 * 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: n10_partitura

 * Autor: Mario Sánchez - 27/09/2005 

 * Modificado por: Daniel Romero - 23/03/2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.interfaz;



import java.awt.Color;

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.JButton;

import javax.swing.JColorChooser;

import javax.swing.JComboBox;

import javax.swing.JPanel;

import javax.swing.JTextField;



/**

 * Este es el panel en el que se modifican las propiedades del titulo de la partitura

 */

public class PanelModificarTitulo extends JPanel implements ActionListener

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    private static final String FUENTE = "Fuente";



    private static final String TAMANO = "Tamaño";



    private static final String ESTILO = "Estilo";



    private static final String COLOR = "Color";



    private static final String CANCELAR = "Cancelar";



    private static final String OK = "Ok";



    // -----------------------------------------------------------------

    // Atributos de la Interfaz

    // -----------------------------------------------------------------



    /**

     * Es una referencia al diálogo que contiene este panel

     */

    private DialogoTituloPartitura dialogo;



    /**

     * Es el comboBox para seleccionar la fuente

     */

    private JComboBox cbbFuente;



    /**

     * Es el comboBox para seleccionar el tamaño de la fuente

     */

    private JComboBox cbbTamano;



    /**

     * Es el comboBox para seleccionar el estilo de la fuente (normal, negrita, itálica)

     */

    private JComboBox cbbEstilo;



    /**

     * Es el campo de texto donde se muestra el texto que quedará en la figura

     */

    private JTextField txtTexto;



    /**

     * Es el botón Ok

     */

    private JButton botonOk;



    /**

     * Es el botón Cancelar

     */

    private JButton botonCancelar;



    /**

     * Es el botón del color del titulo

     */

    private JButton botonColorTitulo;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Inicializa el panel

     * @param dt Es una referencia al diálogo en el que se encuentra el panel

     * @param fuentes Es una lista con los nombres de las fuentes instaladas en el sistema

     */

    public PanelModificarTitulo( DialogoTituloPartitura dt, ArrayList fuentes )

    {

        dialogo = dt;



        setLayout( new GridBagLayout( ) );



        // Inicializa los componentes

        inicializarComponentes( fuentes );



        // Ubica los componentes

        ubicarComponentes( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Ubica los componentes en sus posiciones. <br>

     * <b>pre: </b> Los componentes ya están inicializados

     */

    private void ubicarComponentes( )

    {

        GridBagConstraints gbc;



        gbc = new GridBagConstraints( 0, 0, 4, 1, 0, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( txtTexto, gbc );



        gbc = new GridBagConstraints( 0, 1, 1, 1, 1, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( cbbFuente, gbc );



        gbc = new GridBagConstraints( 1, 1, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( cbbTamano, gbc );



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

        add( cbbEstilo, gbc );



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

        add( botonColorTitulo, gbc );



        JPanel panelBotones = new JPanel( );

        panelBotones.add( botonOk );

        panelBotones.add( botonCancelar );

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

        add( panelBotones, gbc );

    }



    /**

     * Inicializa los componentes

     * @param fuentes Es una lista con los nombres de las fuentes instaladas en el sistema

     */

    private void inicializarComponentes( ArrayList fuentes )

    {

        cbbFuente = new JComboBox( );

        cbbFuente.setActionCommand( FUENTE );

        for( int i = 0; i < fuentes.size( ); i++ )

        {

            String nombreFuente = ( String )fuentes.get( i );

            cbbFuente.addItem( nombreFuente );

        }

        cbbFuente.addActionListener( this );



        cbbTamano = new JComboBox( );

        cbbTamano.setActionCommand( TAMANO );

        for( int i = 8; i <= 32; i += 2 )

        {

            cbbTamano.addItem( new Integer( i ) );

        }

        cbbTamano.addActionListener( this );



        cbbEstilo = new JComboBox( );

        cbbEstilo.setActionCommand( TAMANO );

        cbbEstilo.addItem( "Normal" );

        cbbEstilo.addItem( "Negrita" );

        cbbEstilo.addItem( "Itálica" );

        cbbEstilo.addActionListener( this );



        txtTexto = new JTextField( );



        botonOk = new JButton( "Ok" );

        botonOk.setActionCommand( OK );

        botonOk.addActionListener( this );



        botonCancelar = new JButton( "Cancelar" );

        botonCancelar.setActionCommand( CANCELAR );

        botonCancelar.addActionListener( this );



        botonColorTitulo = new JButton( );

        botonColorTitulo.setActionCommand( COLOR );

        botonColorTitulo.addActionListener( this );



    }



    /**

     * Cambia la fuente del texto mostrado por la seleccionada actualmente en los combo boxes.

     */

    public void actualizarFuente( )

    {

        String nombreFuente = ( String )cbbFuente.getSelectedItem( );

        int tamano = ( ( Integer )cbbTamano.getSelectedItem( ) ).intValue( );

        int numEstilo = cbbEstilo.getSelectedIndex( );



        int estilo = -1;

        switch( numEstilo )

        {

            case 0:

                estilo = Font.PLAIN;

                break;

            case 1:

                estilo = Font.BOLD;

                break;

            case 2:

                estilo = Font.ITALIC;

                break;

            default:

                estilo = Font.PLAIN;

        }



        Font fuente = new Font( nombreFuente, estilo, tamano );

        Color c = botonColorTitulo.getBackground( );

        txtTexto.setFont( fuente );

        txtTexto.setForeground( c );



    }



    /**

     * Cambia el texto mostrado y actualiza los combo box para mostrar la fuente indicada

     * @param texto El texto que se va a mostrar

     * @param fuente La fuente actual del texto

     * @param color El color que va a tener el texto

     */

    public void cambiarTexto( String texto, Font fuente, Color color )

    {

        txtTexto.setText( texto );



        String nombreFuente = fuente.getFamily( );

        int estilo = fuente.getStyle( );

        int tamano = fuente.getSize( );



        boolean encontre = false;

        for( int i = 0; i < cbbFuente.getItemCount( ) && !encontre; i++ )

        {

            String nombre = ( String )cbbFuente.getItemAt( i );

            if( nombre.equals( nombreFuente ) )

            {

                encontre = true;

                cbbFuente.setSelectedIndex( i );

            }

        }



        encontre = false;

        for( int i = 0; i < cbbTamano.getItemCount( ) && !encontre; i++ )

        {

            Integer num = ( Integer )cbbTamano.getItemAt( i );

            if( tamano == num.intValue( ) )

            {

                encontre = true;

                cbbTamano.setSelectedIndex( i );

            }

        }



        switch( estilo )

        {

            case Font.PLAIN:

                cbbEstilo.setSelectedIndex( 0 );

                break;

            case Font.BOLD:

                cbbEstilo.setSelectedIndex( 1 );

                break;

            case Font.ITALIC:

                cbbEstilo.setSelectedIndex( 2 );

                break;

            default:

                cbbEstilo.setSelectedIndex( 0 );

        }



        txtTexto.setForeground( color );

        botonColorTitulo.setBackground( color );

    }



    /**

     * Es el método que ejecuta la acción que se debe ejecutar cuando se hace click sobre un botón

     * @param evento Es el evento del click sobre un botón

     */

    public void actionPerformed( ActionEvent evento )

    {

        String comando = evento.getActionCommand( );



        if( OK.equals( comando ) )

        {

            String texto = txtTexto.getText( );

            Font fuente = txtTexto.getFont( );



            dialogo.cambiarTitulo( texto, fuente, botonColorTitulo.getBackground( ) );

        }

        else if( CANCELAR.equals( comando ) )

        {

            dialogo.dispose( );

        }

        else if( FUENTE.equals( comando ) || TAMANO.equals( comando ) || ESTILO.equals( comando ) )

        {

            actualizarFuente( );

        }

        else if( COLOR.equals( comando ) )

        {

            Color colorT = JColorChooser.showDialog( this, "Color del fondo", botonColorTitulo.getBackground( ) );

            botonColorTitulo.setBackground( colorT );

            actualizarFuente( );

        }



    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: PanelOpciones.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Romero - 23/03/2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.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.JComboBox;

import javax.swing.JPanel;

import javax.swing.border.CompoundBorder;

import javax.swing.border.EmptyBorder;

import javax.swing.border.TitledBorder;



/**

 * Panel que contiene los botones para realizar acciones con la partitura

 */

public class PanelOpciones extends JPanel implements ActionListener

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    private static final String COMPONER = "Componer";



    private static final String PRACTICA_GUIADA = "Práctica Guiada";



    private static final String PRACTICA_LIBRE = "Práctica Libre";



    private static final String MODO = "Modo";



    private final static String OPCION_1 = "OPCION_1";



    private final static String OPCION_2 = "OPCION_2";



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Ventana principal de la aplicación

     */

    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Atributos de Interfaz

    // -----------------------------------------------------------------



    /**

     * El botón para tocar la partitura

     */

    private JButton botonTocarPartitura;



    /**

     * El combo con los distintos modos en los que se puede trabajar en la partitura

     */

    private JComboBox cbbModos;



    /**

     * El combo con los distintas clases de notas

     */

    private JComboBox cbbClasesNotas;



    /**

     * El botón para la extensión 1

     */

    private JButton opcion1;



    /**

     * El botón para la extensión 2

     */

    private JButton opcion2;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Crea el panel con los botones para realizar las acciones en la partitura

     * @param interfaz Es una referencia a la ventana principal de la aplicación

     */

    public PanelOpciones( InterfazPartitura interfaz )

    {

        principal = interfaz;

        inicializarElementos( );



        // ubica los elementos en la interfaz

        GridBagLayout gridbag1 = new GridBagLayout( );

        setLayout( gridbag1 );

        setBorder( new CompoundBorder( new EmptyBorder( 10, 10, 10, 10 ), new TitledBorder( "Elija la acción a realizar" ) ) );



        GridBagConstraints gbc1;



        gbc1 = new GridBagConstraints( 0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( cbbModos, gbc1 );



        gbc1 = new GridBagConstraints( 1, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( botonTocarPartitura, gbc1 );



        gbc1 = new GridBagConstraints( 2, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( cbbClasesNotas, gbc1 );



        gbc1 = new GridBagConstraints( 3, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( opcion1, gbc1 );



        gbc1 = new GridBagConstraints( 4, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets( 5, 5, 5, 5 ), 0, 0 );

        add( opcion2, gbc1 );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Inicializa los elementos del panel

     */

    private void inicializarElementos( )

    {

        // Asigna valores a los botones

        opcion1 = new JButton( );

        opcion1.setText( "Opción 1" );

        opcion1.setActionCommand( OPCION_1 );

        opcion1.addActionListener( this );



        opcion2 = new JButton( );

        opcion2.setText( "Opción 2" );

        opcion2.setActionCommand( OPCION_2 );

        opcion2.addActionListener( this );



        botonTocarPartitura = new JButton( );

        botonTocarPartitura.setText( "Escuchar Partitura" );

        botonTocarPartitura.setActionCommand( PRACTICA_GUIADA );

        botonTocarPartitura.addActionListener( this );

        botonTocarPartitura.setEnabled( false );



        cbbModos = new JComboBox( );

        cbbModos.addItem( PRACTICA_LIBRE );

        cbbModos.addItem( PRACTICA_GUIADA );

        cbbModos.addItem( COMPONER );

        cbbModos.setActionCommand( MODO );

        cbbModos.addActionListener( this );



        cbbClasesNotas = new JComboBox( );

        cbbClasesNotas.addItem( "Redonda" );

        cbbClasesNotas.addItem( "Blanca" );

        cbbClasesNotas.addItem( "Negra" );

        cbbClasesNotas.addItem( "Corchea" );

        cbbClasesNotas.addItem( "Semicorchea" );

        cbbClasesNotas.setEnabled( false );



    }



    /**

     * Responde con acciones en el mundo dependiendo de las acciones en la interfaz

     * @param evento El evento realizado por el usuario en la interfaz - evento!=null

     */

    public void actionPerformed( ActionEvent evento )

    {

        String comando = evento.getActionCommand( );

        if( comando.equals( COMPONER ) )

        {

            principal.cambiarModo( InterfazPartitura.COMPONER );

            principal.limpiarPartitura( );

        }

        else if( comando.equals( PRACTICA_GUIADA ) )

        {

            principal.tocarMelodia( );

        }

        else if( comando.equals( PRACTICA_LIBRE ) )

        {

            principal.cambiarModo( InterfazPartitura.LIBRE );

            principal.limpiarPartitura( );

            botonTocarPartitura.setEnabled( false );

        }

        else if( comando.equals( MODO ) )

        {

            String modo = ( String )cbbModos.getSelectedItem( );



            if( modo.equals( PRACTICA_LIBRE ) )

            {

                botonTocarPartitura.setEnabled( false );

                cbbClasesNotas.setEnabled( false );

                principal.cambiarModo( InterfazPartitura.LIBRE );

                principal.reiniciarPartitura( );

            }

            else if( modo.equals( PRACTICA_GUIADA ) )

            {

                principal.cambiarModo( InterfazPartitura.GUIADA );

                botonTocarPartitura.setEnabled( true );

                cbbClasesNotas.setEnabled( false );

                principal.reiniciarPartitura( );

            }

            else if( modo.equals( COMPONER ) )

            {

                botonTocarPartitura.setEnabled( false );

                cbbClasesNotas.setEnabled( true );

                principal.cambiarModo( InterfazPartitura.COMPONER );

                principal.reiniciarPartitura( );

            }

        }

        else if( comando.equals( OPCION_1 ) )

        {

            principal.reqFuncOpcion1( );

        }

        else if( comando.equals( OPCION_2 ) )

        {

            principal.reqFuncOpcion2( );

        }

    }



    /**

     * Retorna la clase de nota seleccionada

     * @return Clase de nota seleccionada

     */

    public String darClaseNota( )

    {

        return ( String )cbbClasesNotas.getSelectedItem( );

    }

}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: PanelPartitura.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero- Marzo 21, 2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.interfaz;



import java.awt.BasicStroke;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridBagLayout;

import java.awt.RenderingHints;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;



import javax.swing.JPanel;

import javax.swing.border.CompoundBorder;

import javax.swing.border.EmptyBorder;

import javax.swing.border.TitledBorder;



import uniandes.cupi2.partitura.mundo.Partitura;



/**

 * Panel que muestra la partitura guía de la canción a tocar

 */

public class PanelPartitura extends JPanel implements MouseListener

{

    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------

    /**

     * Ventana principal de la aplicación

     */

    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye un panel para visualizar una partitura

     * @param interP Es una referencia a la ventana principal de la aplicación

     */

    public PanelPartitura( InterfazPartitura interP )

    {

        // dispone la organización de la partitura

        GridBagLayout gridbag1 = new GridBagLayout( );

        setLayout( gridbag1 );

        setBorder( new CompoundBorder( new EmptyBorder( 10, 10, 10, 10 ), new TitledBorder( "" ) ) );

        setDoubleBuffered( true );

        setPreferredSize( new Dimension( Partitura.ANCHO_PARTITURA, Partitura.ALTO_PARTITURA ) );

        addMouseListener( this );



        // Inicializa los atributos

        principal = interP;



        // Pinta la partitura

        actualizar( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Este método se encarga de actualizar la visualización de la partitura

     */

    public void actualizar( )

    {

        repaint( );

        validate( );

    }



    /**

     * Este es el método que se encarga de actualizar la visualización de la partitura

     * @param g Es la superficie del panel

     */

    public void update( Graphics2D g )

    {

        g.setStroke( new BasicStroke( 1 ) );

        g.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );

        g.setColor( getBackground( ) );

        g.fillRect( 0, 0, getWidth( ), getHeight( ) );



        // Dibujar la partitura

        principal.pintarPartitura( g );



    }



    /**

     * Este es el método llamado por la máquina virtual cuando hay que repintar el panel. <br>

     * <code>super.paint( g )</code> no sabe pintar las figuras, así que hay que<br>

     * sobrecargar el método.<br>

     * @param g Es la superficie del panel

     */

    public void paintComponent( Graphics g )

    {

        super.paintComponent( g );

        update( ( Graphics2D )g );

    }



    /**

     * Repinta la partitura.

     * @param g La superficie del componente

     */

    public void paintComponents( Graphics g )

    {

        super.paintComponents( g );



        validate( );

    }



    /**

     * Este método se llama cuando se hace click sobre la superficie del panel partitura. <br>

     * Dependiendo de la opción seleccionada se debe agregar una figura al mapa o se debe <br>

     * seleccionar una de las figuras existentes. <br>

     * Si la opción seleccionada es SELECCIONAR y se hace doble click sobre una figura se<br>

     * debe poder cambiar su texto.

     * @param evento Es el evento del clic sobre el panel

     */

    public void mouseClicked( MouseEvent evento )

    {

        if( evento.getButton( ) == MouseEvent.BUTTON1 )

        {

            if( evento.getClickCount( ) == 2 )

            {

                principal.mostrarVentanaTitulo( );

            }

        }

        else if( evento.getButton( ) == MouseEvent.BUTTON3 )

        {

            int x = evento.getX( );

            int y = evento.getY( );

            int posNota = principal.buscarNota( x, y );

            if( posNota != -1 )

            {

                PopupMenuNota menu = new PopupMenuNota( this, posNota );



                menu.setInvoker( this );

                menu.setEnabled( true );

                menu.setLocation( x, y );

                menu.setVisible( true );



            }

        }



    }



    /**

     * Este método no se implementa

     * @param evento El evento

     */

    public void mousePressed( MouseEvent arg0 )

    {

        // No se requiere

    }



    /**

     * Este método no se implementa

     * @param evento El evento

     */

    public void mouseReleased( MouseEvent arg0 )

    {

        // No se requiere



    }



    /**

     * Este método no se implementa

     * @param evento El evento

     */

    public void mouseEntered( MouseEvent arg0 )

    {

        // No se requiere

    }



    /**

     * Este método no se implementa

     * @param evento El evento

     */

    public void mouseExited( MouseEvent arg0 )

    {

        // No se requiere



    }



    /**

     * Elimina la nota en la posición especificada

     * @param posNota Posición de la nota a ser eliminada

     */

    public void eliminarNota( int posNota )

    {



        principal.eliminarNota( posNota );



    }



    /**

     * Muestra la ventana para modificar la información de la nota en la posición especificada

     * 

     */

    public void mostrarVentanaInformacionNota( int pos )

    {

        principal.mostrarVentanaInformacionNota( pos );



    }



}


/**

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: PanelTeclado.java 600 2006-11-06 06:16:53Z da-romer $ 

 * 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: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero Acero - 25-ene-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.interfaz;



import java.awt.Color;

import java.awt.Dimension;

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;



import uniandes.cupi2.partitura.mundo.Nota;



/**

 * Panel con el teclado

 */

public class PanelTeclado extends JPanel implements ActionListener

{

    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Ventana principal de la aplicación

     */

    private InterfazPartitura principal;



    /**

     * Si se esta tocando en modo partitura= InterfazPartitura.PARTITURA, si se esta tocando en modo libre = InterfazPartitura.LIBRE, si se está tocando en modo composición=

     * InterfazPartitura.COMPOSICION

     */

    private int modoTeclado;



    // -----------------------------------------------------------------

    // Atributos de Interfaz

    // -----------------------------------------------------------------



    /**

     * El arreglo de botones que conforman el teclado

     */

    private JButton[] teclas;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Crea un panel que simula un teclado de piano

     * @param interfaz La ventana principal de la aplicación

     */

    public PanelTeclado( InterfazPartitura interfaz )

    {

        // inicializa los elementos necesarios para el funcionamiento del panel

        principal = interfaz;

        // posicionActual = -1;

        setBackground( Color.WHITE );

        setPreferredSize( new Dimension( 783, 233 ) );



        modoTeclado = InterfazPartitura.LIBRE;

        inicializarElementos( );

        pintarTeclado( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Dibuja un teclado en la pantalla usando un botón para cada nota

     */

    private void pintarTeclado( )

    {

        // crea la forma en que se ubicarán las teclas

        setLayout( new GridLayout( 1, 13 ) );

        setBorder( new CompoundBorder( new EmptyBorder( 10, 10, 10, 10 ), new TitledBorder( "" ) ) );



        // se agrega en orden: DO-DOS-RE-RES-MI-FA-FAS-SOL-SOLS-LA-LAS-SI-DO2

        for( int i = 0; i < teclas.length; i++ )

        {

            add( teclas[ i ] );

        }



    }



    /**

     * Inicializa los elementos del panel de teclado: inicializa cada botón con un texto de<br>

     * acción un color de texto y de fondo

     */

    private void inicializarElementos( )

    {



        teclas = new JButton[13];

        // Se crean en orden: DO-DOS-RE-RES-MI-FA-FAS-SOL-SOLS-LA-LAS-SI-DO2

        teclas[ 0 ] = inicializarBoton( Nota.DO, Color.WHITE, Color.BLACK, Nota.DO );

        teclas[ 1 ] = inicializarBoton( Nota.DOS, Color.BLACK, Color.WHITE, Nota.DOS );

        teclas[ 2 ] = inicializarBoton( Nota.RE, Color.WHITE, Color.BLACK, Nota.RE );

        teclas[ 3 ] = inicializarBoton( Nota.RES, Color.BLACK, Color.WHITE, Nota.RES );

        teclas[ 4 ] = inicializarBoton( Nota.MI, Color.WHITE, Color.BLACK, Nota.MI );

        teclas[ 5 ] = inicializarBoton( Nota.FA, Color.WHITE, Color.BLACK, Nota.FA );

        teclas[ 6 ] = inicializarBoton( Nota.FAS, Color.BLACK, Color.WHITE, Nota.FAS );

        teclas[ 7 ] = inicializarBoton( Nota.SOL, Color.WHITE, Color.BLACK, Nota.SOL );

        teclas[ 8 ] = inicializarBoton( Nota.SOLS, Color.BLACK, Color.WHITE, Nota.SOLS );

        teclas[ 9 ] = inicializarBoton( Nota.LA, Color.WHITE, Color.BLACK, Nota.LA );

        teclas[ 10 ] = inicializarBoton( Nota.LAS, Color.BLACK, Color.WHITE, Nota.LAS );

        teclas[ 11 ] = inicializarBoton( Nota.SI, Color.WHITE, Color.BLACK, Nota.SI );

        teclas[ 12 ] = inicializarBoton( Nota.DO, Color.WHITE, Color.BLACK, Nota.DO2 );

    }



    /**

     * Crea e inicializa un botón con con los parámetros dados

     * @param texto El texto del botón

     * @param backGround Color de fondo

     * @param foreGround Color de la letra

     * @param accion Para el actionCommand

     * @return Un botón inicializado con los parámetros dados

     */

    private JButton inicializarBoton( String texto, Color backGround, Color foreGround, String accion )

    {

        JButton boton = new JButton( );

        boton.setText( texto );

        boton.setBackground( backGround );

        boton.setForeground( foreGround );

        boton.setActionCommand( accion );

        boton.addActionListener( this );

        return boton;

    }



    /**

     * Cambia el tipo de practica : InterfazPartitura.LIBRE o InterfazPartitura.PARTITURA

     * @param tipo Indica el tipo de práctica : InterfazPartitura.LIBRE, InterfazPartitura.PARTITURA <br>

     *        o InterfazPartitura.COMPOSICION

     */

    public void cambiarModo( int tipo )

    {

        modoTeclado = tipo;

    }



    /**

     * Retorna el modo del teclado

     * @return Modo del teclado

     */

    public int darModo( )

    {

        return modoTeclado;



    }



    /**

     * Bloquea el teclado para que no se pueda seguir tocando

     * 

     */

    public void bloquearTeclado( )

    {

        for( int i = 0; i < teclas.length; i++ )

        {

            teclas[ i ].setEnabled( false );

        }

    }



    /**

     * Desbloquea el teclado para que se pueda seguir tocando

     * 

     */

    public void desbloquearTeclado( )

    {

        for( int i = 0; i < teclas.length; i++ )

        {

            teclas[ i ].setEnabled( true );

        }

    }



    /**

     * Responde con acciones en el mundo dependiendo de las acciones en la interfaz

     * @param evento El evento realizado por el usuario en la interfaz

     */

    public void actionPerformed( ActionEvent evento )

    {

        // Toca la nota correspondiente según el botón en el que se haya hecho click

        String comando = evento.getActionCommand( );

        principal.tocarNota( comando );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: PopupMenuNota.java 463 2006-10-10 15:45:29Z da-romer $ 

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 25-ene-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.interfaz;



import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;



import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;



/**

 * Menú con las opciones para modificar una nota

 */

public class PopupMenuNota extends JPopupMenu implements ActionListener

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    private static final String ELIMINAR = "Eliminar";



    private static final String CAMBIAR_INFORMACION = "CambiarInformacion";



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------

    /**

     * Es una referencia a la partitura en la que se despliega el menú

     */

    private PanelPartitura panel;



    /**

     * Posición de la nota asociada con el menú

     */

    private int posNota;



    // -----------------------------------------------------------------

    // Atributos de la Interfaz

    // -----------------------------------------------------------------



    /**

     * La opción para eliminar una nota

     */

    JMenuItem itemEliminar;



    /**

     * la opción para cambiar los atributos de la nota

     */

    JMenuItem itemCambiarInformacionNota;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye el popup menú

     * @param panel Es una referencia al panel en el que se despliega el menú

     * @param pNota Posición de la nota asociada con el menú

     */

    public PopupMenuNota( PanelPartitura pP, int pNota )

    {

        panel = pP;

        posNota = pNota;

        setInvoker( panel );



        itemCambiarInformacionNota = new JMenuItem( "Cambiar Información" );

        itemCambiarInformacionNota.setActionCommand( CAMBIAR_INFORMACION );

        itemCambiarInformacionNota.addActionListener( this );

        add( itemCambiarInformacionNota );



        itemEliminar = new JMenuItem( "Eliminar" );

        itemEliminar.setActionCommand( ELIMINAR );

        itemEliminar.addActionListener( this );

        add( itemEliminar );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Ejecuta la acción que corresponde a la opción del menú que fue seleccionada

     * @param evento Es el evento de seleccionar una opción del menú

     */

    public void actionPerformed( ActionEvent evento )

    {



        String comando = evento.getActionCommand( );



        if( CAMBIAR_INFORMACION.equals( comando ) )

        {

            panel.mostrarVentanaInformacionNota( posNota );

        }

        else if( ELIMINAR.equals( comando ) )

        {

            pedirConfirmacion( );

        }

    }



    /**

     * Este método solicita una confirmación para eliminar una nota. <br>

     * Presenta una ventana con las opciones "Si" y "No". <br>

     * Si se selecciona "Si", entonces se elimina la nota. <br>

     * Si se selecciona "No", la nota no se elimina <br>

     */

    private void pedirConfirmacion( )

    {



        int respuesta = JOptionPane.showConfirmDialog( panel, "Desea eliminar la nota?", "Eliminar Nota", JOptionPane.YES_NO_OPTION, JOptionPane.INFORMATION_MESSAGE );



        if( respuesta == JOptionPane.YES_OPTION )

        {

            panel.eliminarNota( posNota );

        }

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: ReproductorNota.java 516 2006-10-23 05:06:15Z da-romer $ 

 * 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: n5_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero Acero - 25-ene-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.interfaz;



import javax.sound.midi.MidiChannel;

import javax.sound.midi.MidiSystem;

import javax.sound.midi.MidiUnavailableException;

import javax.sound.midi.Synthesizer;



/**

 * Clase que permite tocar una nota

 */

public class ReproductorNota

{

    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Es el canal que se usa para reproducir las notas

     */

    private MidiChannel channel;



    /**

     * Es el sintetizador con el que se reproducen las notas

     */

    private Synthesizer synth;



    private InterfazPartitura principal;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Crea un nuevo reproductor de notas a partir de un sintetizador

     */

    public ReproductorNota( InterfazPartitura p )

    {

        try

        {

            // obtiene un sintetizador del sistema

            synth = MidiSystem.getSynthesizer( );

            // abre el sintetizador

            synth.open( );

            principal = p;

        }

        catch( MidiUnavailableException e )

        {

            e.printStackTrace( );

        }

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Toca la nota indicada, las notas van de 0 a 120 siendo 60 el Do central, 61 Do#, etc

     * @param nota Valor numérico de la nota a reproducir

     * @param canal El instrumento con el que se quiere tocar la nota. Van de 0 a 15. 0, es el piano

     * @param duracion La duración de la nota

     * @param posNota La posición de la nota que se está tocando

     */

    public synchronized void tocarNota( int nota, int canal, double duracion, int posNota )

    {

        final int notaT = nota;

        final int canalT = canal;

        final double dur = duracion;

        final int pNota = posNota;



        Thread t = new Thread( new Runnable( )

        {

            public void run( )

            {

                synchronized( synth )

                {



                    // define el instrumento a tocar

                    channel = synth.getChannels( )[ canalT ];

                    // prende la nota indicada en el numero dado, con un tiempo de decaimiento promedio

                    channel.noteOn( notaT, 100 );



                    // Pinta la nota como marcada

                    if( pNota != -1 )

                    {

                        principal.cambiarPosicionNotaMarcada( pNota );

                    }



                    principal.repintarPartitura( );



                    // Realiza una espera para darle duración a la nota

                    try

                    {

                        Thread.yield( );

                        Thread.sleep( ( long ) ( dur * 200 ) );

                    }

                    catch( InterruptedException e )

                    {

                        e.printStackTrace( );

                    }



                    // apaga la nota tocada

                    channel.noteOff( notaT, 100 );

                }

            }

        } );



        t.run( );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: Blanca.java 600 2006-11-06 06:16:53Z da-romer $

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 21-marzo-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.BufferedReader;

import java.io.IOException;



/**

 * Esta es una clase que representa una blanca en la partitura

 */

public class Blanca extends Nota

{



    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    public static final double DURACION = 2;



    public static final String CLASE = "Blanca";



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una blanca

     * @param nom El nombre de la blanca

     * @param tip El tipo de la blanca

     * @param co Color de la blanca

     */

    public Blanca( String nom, String tip, Color co )

    {

        super( nom, tip, co );



    }



    /**

     * Crea la blanca a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Blanca( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {

        super( br );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------

    /**

     * Retorna la duración de la nota

     */

    public double darDuracion( )

    {

        return DURACION;

    }



    /**

     * Retorna la clase de la nota

     */

    public String darClase( )

    {

        return CLASE;

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected void pintar( Graphics2D g, int posicion, Color c )

    {

        // Pintar el circulo

        g.setColor( c );

        int coordenadaX = calcularCoordenadaXNota( posicion );

        int coordenadaY = calcularCoordenadaYNota( posicion );



        g.drawOval( coordenadaX, coordenadaY, ANCHO_NOTA, ALTO_NOTA );



        // Pintar la línea

        int coordenadaXLinea = calcularCoordenadaXNota( posicion ) + ANCHO_NOTA;

        int coordenadaYLinea = calcularCoordenadaYNota( posicion ) + ALTO_NOTA / 2;



        g.drawLine( coordenadaXLinea, coordenadaYLinea, coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA );



        // Si la nota es DO se debe pintar la línea que atraviesa la nota

        if( nombre.equalsIgnoreCase( DO ) )

        {

            g.drawLine( coordenadaX - 5, coordenadaY + ALTO_NOTA / 2, coordenadaX + ANCHO_NOTA + 5, coordenadaY + ALTO_NOTA / 2 );

        }



        pintarSostenido( g, posicion, c );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: Corchea.java 600 2006-11-06 06:16:53Z da-romer $

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 21-marzo-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.BufferedReader;

import java.io.IOException;



/**

 * Esta es una clase que representa una corchea en la partitura

 */

public class Corchea extends Nota

{



    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    public static final double DURACION = 0.5;



    public static final String CLASE = "Corchea";



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una corchea

     * @param nom El nombre de la corchea

     * @param tip El tipo de la corchea

     * @param co Color de la corchea

     */

    public Corchea( String nom, String tip, Color co )

    {

        super( nom, tip, co );



    }



    /**

     * Crea la corchea a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Corchea( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {

        super( br );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Retorna la duración de la nota

     */

    public double darDuracion( )

    {

        return DURACION;

    }



    /**

     * Retorna la clase de la nota

     */

    public String darClase( )

    {

        return CLASE;

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected void pintar( Graphics2D g, int posicion, Color c )

    {

        g.setColor( c );

        int coordenadaX = calcularCoordenadaXNota( posicion );

        int coordenadaY = calcularCoordenadaYNota( posicion );



        g.fillOval( coordenadaX, coordenadaY, ANCHO_NOTA, ALTO_NOTA );



        // Pintar la línea

        int coordenadaXLinea = calcularCoordenadaXNota( posicion ) + ANCHO_NOTA;

        int coordenadaYLinea = calcularCoordenadaYNota( posicion ) + ALTO_NOTA / 2;



        g.drawLine( coordenadaXLinea, coordenadaYLinea, coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA );



        // Pintar la línea horizontal

        g.drawLine( coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA, coordenadaXLinea + 5, coordenadaYLinea - ALTO_LINEA_NOTA + 5 );



        // Si la nota es DO se debe pintar la línea que atraviesa la nota

        if( nombre.equalsIgnoreCase( DO ) )

        {

            g.drawLine( coordenadaX - 5, coordenadaY + ALTO_NOTA / 2, coordenadaX + ANCHO_NOTA + 5, coordenadaY + ALTO_NOTA / 2 );

        }



        pintarSostenido( g, posicion, c );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: FormatoInvalidoExcepcion.java 514 2006-10-23 04:50:08Z da-romer $ 

 * Universidad de los Andes (Bogotá - Colombia)

 * Departamento de Ingeniería de Sistemas y Computación 

 * Todos los derechos reservados 2005 

 *

 * Proyecto Cupi2 

 * Ejercicio: n10_partitura 

 * Autor: Mario Sánchez - 27/09/2005 

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */

package uniandes.cupi2.partitura.mundo;



/**

 * Esta Excepción se lanza si hay un problema con el formato del archivo leído

 */

public class FormatoInvalidoExcepcion extends Exception

{

    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye la excepción

     * @param linea La línea que tiene un formato inválido

     */

    public FormatoInvalidoExcepcion( String linea )

    {

        super( "El formato de la línea es inválido:" + linea );

    }

}


package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.PrintWriter;



/**

 * Interfaz con los servicios que debe proporcionar una nota

 */

public interface INota

{

    /**

     * Retorna el nombre de la nota

     * @return Nombre de la nota (do, re, mi, fa, sol, la, si, do2)

     */

    public String darNombre( );



    /**

     * Retorna el tipo de la nota

     * @return Tipo de la nota (normal (n),sostenido(#))

     */

    public String darTipo( );



    /**

     * Sirve para pintar la nota

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     */

    public void pintarNota( Graphics2D g, int posicion );



    /**

     * Sirve para pintar la nota de color rojo (o magenta si el color de la nota es rojo), indicando que está marcada

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     */

    public void pintarNotaMarcada( Graphics2D g, int posicion );



    /**

     * Retorna la duración asociada con la nota

     * @return Duración de la nota

     */

    public double darDuracion( );



    /**

     * Retorna la clase de la nota (redonda, blanca, negra, corchea, semicorchea)

     * @return Clase de la nota

     */

    public String darClase( );



    /**

     * Retorna un valor numérico correspondiente a la posición de la nota en el pentagrama: <br>

     * 11 para DO, 10 para RE, 9 para MI, 8 para FA, 7 para SOL, 6 para LA, 5 para SI, 4 para DO2

     * @return Posición de la nota en el pentagrama de la nota

     */

    public int darPosicionNotaPentagrama( );



    /**

     * Sirve para saber si un punto está dentro de la nota o no.

     * @param px Es la coordenada x del punto

     * @param py Es la coordenada y del punto

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @return Retorna true si el punto está dentro de la nota. Retorna false en caso contrario.

     */

    public boolean estaDentro( int px, int py, int posicion );



    /**

     * Modifica el tipo de la nota

     * @param t Nuevo tipo de la nota

     */

    public void cambiarTipo( String t );



    /**

     * Cambia el color de la nota

     * @param c Nuevo color de la nota

     */

    public void cambiarColor( Color c );



    /**

     * Cambia el nombre de la nota

     * @param nom Nuevo nombre de la nota

     */

    public void cambiarNombre( String nom );



    /**

     * Retorna el color de la nota

     * @return Color de la nota

     */

    public Color darColor( );

    

    /**

     * Este método sirve para guardar la nota en un archivo

     * @param out Es el stream donde se va a guardar la nota

     */

    public void guardar( PrintWriter out );



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: Negra.java 600 2006-11-06 06:16:53Z da-romer $

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 21-marzo-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.BufferedReader;

import java.io.IOException;



/**

 * Esta es una clase que representa una negra en la partitura

 */

public class Negra extends Nota

{



    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    public static final double DURACION = 1;



    public static final String CLASE = "Negra";



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una negra

     * @param nom El nombre de la negra

     * @param tip El tipo de la negra

     * @param co Color de la negra

     */

    public Negra( String nom, String tip, Color co )

    {

        super( nom, tip, co );



    }



    /**

     * Crea la negra a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Negra( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {

        super( br );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------

    /**

     * Retorna la duración de la nota

     */

    public double darDuracion( )

    {

        return DURACION;

    }



    /**

     * Retorna la clase de la nota

     */

    public String darClase( )

    {

        return CLASE;

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected void pintar( Graphics2D g, int posicion, Color c )

    {

        g.setColor( c );

        int coordenadaX = calcularCoordenadaXNota( posicion );

        int coordenadaY = calcularCoordenadaYNota( posicion );



        g.fillOval( coordenadaX, coordenadaY, ANCHO_NOTA, ALTO_NOTA );



        // Pintar la línea

        int coordenadaXLinea = calcularCoordenadaXNota( posicion ) + ANCHO_NOTA;

        int coordenadaYLinea = calcularCoordenadaYNota( posicion ) + ALTO_NOTA / 2;



        g.drawLine( coordenadaXLinea, coordenadaYLinea, coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA );



        // Si la nota es DO se debe pintar la línea que atraviesa la nota

        if( nombre.equalsIgnoreCase( DO ) )

        {

            g.drawLine( coordenadaX - 5, coordenadaY + ALTO_NOTA / 2, coordenadaX + ANCHO_NOTA + 5, coordenadaY + ALTO_NOTA / 2 );

        }



        pintarSostenido( g, posicion, c );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: Nota.java 604 2006-11-07 04:47:33Z da-romer $ 

 * Universidad de los Andes (Bogotá - Colombia) 

 * Departamento de Ingeniería de Sistemas y Computación 

 * Todos los derechos reservados 2005 

 * 

 * Proyecto Cupi2 

 * Ejercicio: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero- Marzo 21, 2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.PrintWriter;



/**

 * Esta es una clase abstracta que representa una nota en la partitura. <br>

 * <b>inv: </b> <br>

 * (tipo= Sostenido o tipo= Normal) y (nombre= DO o nombre= RE o nombre= MI o nombre= FA o nombre= SOL o nombre= LA o nombre= SI o nombre= DO2)<br>

 */

public abstract class Nota implements INota

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------



    public static final String NORMAL = "Normal";



    public static final String SOSTENIDO = "Sostenido";



    public static final String DO = "DO";



    public static final String RE = "RE";



    public static final String MI = "MI";



    public static final String FA = "FA";



    public static final String SOL = "SOL";



    public static final String LA = "LA";



    public static final String SI = "SI";



    public static final String DO2 = "DO2";



    public static final String DOS = "DO#";



    public static final String RES = "RE#";



    public static final String FAS = "FA#";



    public static final String SOLS = "SOL#";



    public static final String LAS = "LA#";



    public static final int ALTO_NOTA = 12;



    public static final int ANCHO_NOTA = 12;



    public static final int ALTO_LINEA_NOTA = 30;



    public static final int ESPACIO_NOTAS_HORIZONTAL = 32;



    public static final int ESPACIO_NOTAS_VERTICAL = 6;



    public static final int LONGITUD_LINEAS_SOSTENIDO = 4;



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * El nombre de la nota (do, re, mi fa, sol, la, si, do2)

     */

    protected String nombre;



    /**

     * El tipo de la nota (normal, sostenido)

     */

    protected String tipo;



    /**

     * Color de fondo de la construcción

     */

    protected Color color;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una nota

     * @param nom El nombre de la nota

     * @param tip El tipo de la nota

     * @param co Color de fondo de la nota

     * 

     */

    public Nota( String nom, String tip, Color co )

    {

        nombre = nom;

        tipo = tip;

        color = co;

        verificarInvariante( );

    }



    /**

     * Crea una construcción a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Nota( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {



        String pos = null;

        String lineaColor;



        try

        {

            tipo = br.readLine( );

            nombre = br.readLine( );

            // pos= br.readLine( );

            // posicion = Integer.parseInt(pos);

            lineaColor = br.readLine( );

            inicializarColor( lineaColor );



        }

        catch( NumberFormatException fie )

        {

            br.close( );

            throw new FormatoInvalidoExcepcion( pos );

        }

        verificarInvariante( );

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Retorna el nombre de la nota

     * @return Nombre de la nota (do, re, mi, fa, sol, la, si, do2)

     */

    public String darNombre( )

    {

        return nombre;

    }



    /**

     * Retorna el tipo de la nota

     * @return Tipo de la nota (normal (n),sostenido(#))

     */

    public String darTipo( )

    {

        return tipo;

    }



    /**

     * Sirve para pintar la semicorchea

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     */

    public void pintarNota( Graphics2D g, int posicion )

    {

        pintar( g, posicion, color );

    }



    /**

     * Sirve para pintar la corchea seleccionada

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     */

    public void pintarNotaMarcada( Graphics2D g, int posicion )

    {



        Color c = Color.RED;



        if( color.equals( Color.RED ) )

        {

            c = Color.BLUE;



        }

        pintar( g, posicion, c );

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected abstract void pintar( Graphics2D g, int posicion, Color c );



    /**

     * Retorna la duración asociada con la nota

     * @return duración de la nota

     */

    public abstract double darDuracion( );



    /**

     * Retorna la clase de la nota (redonda, blanca, negra, corchea, semicorchea)

     * @return Clase de la nota

     */

    public abstract String darClase( );



    /**

     * Pinta el sostenido de la nota si es de este tipo basándose en las coordenadas de la nota

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se debe pintar

     */

    protected void pintarSostenido( Graphics2D g, int posicion, Color c )

    {

        if( tipo.equalsIgnoreCase( SOSTENIDO ) )

        {

            int coordenadaX = calcularCoordenadaXNota( posicion );

            int coordenadaY = calcularCoordenadaYNota( posicion );



            g.setColor( c );



            // Primera línea horizontal

            g.drawLine( coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO, coordenadaY + LONGITUD_LINEAS_SOSTENIDO, coordenadaX + ANCHO_NOTA + 4 + LONGITUD_LINEAS_SOSTENIDO * 2, coordenadaY + LONGITUD_LINEAS_SOSTENIDO );



            // Segunda línea horizontal

            g.drawLine( coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO, coordenadaY + LONGITUD_LINEAS_SOSTENIDO * 2, coordenadaX + ANCHO_NOTA + 4 + LONGITUD_LINEAS_SOSTENIDO * 2, coordenadaY + LONGITUD_LINEAS_SOSTENIDO * 2 );



            // Primera línea vertical

            g.drawLine( coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO + 2, coordenadaY + LONGITUD_LINEAS_SOSTENIDO - 2, coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO + 2, coordenadaY + LONGITUD_LINEAS_SOSTENIDO - 2

                    + LONGITUD_LINEAS_SOSTENIDO * 2 );



            // Segunda línea vertical

            g.drawLine( coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO + 2 + LONGITUD_LINEAS_SOSTENIDO, coordenadaY + LONGITUD_LINEAS_SOSTENIDO - 2, coordenadaX + ANCHO_NOTA + LONGITUD_LINEAS_SOSTENIDO + 2 + LONGITUD_LINEAS_SOSTENIDO,

                    coordenadaY + LONGITUD_LINEAS_SOSTENIDO - 2 + LONGITUD_LINEAS_SOSTENIDO * 2 );



        }



    }



    /**

     * Calcula la coordenada x de la nota de acuerdo a su posición dentro de la partitura <br>

     * y al espacio horizontal que se debe dejar entre las notas

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @return La coordenada en x de la nota

     */

    protected int calcularCoordenadaXNota( int posicion )

    {

        int coordenadaX = 0;



        if( ( posicion + 2 ) * ESPACIO_NOTAS_HORIZONTAL > Partitura.ANCHO_PARTITURA ) // Si ya se lleno la

        // primera partitura se pasa a la siguiente

        {

            coordenadaX = ( ( ( ( ( posicion + 1 ) % ( Partitura.NUM_MAX_NOTAS / 2 + 1 ) ) + 1 ) + 1 ) * ESPACIO_NOTAS_HORIZONTAL );

        }

        else

        {

            coordenadaX = ( ( ( ( posicion + 1 ) % ( Partitura.NUM_MAX_NOTAS / 2 + 1 ) ) + 1 ) * ESPACIO_NOTAS_HORIZONTAL );

        }



        return coordenadaX;

    }



    /**

     * Calcula la coordenada y de la nota de acuerdo a su posición dentro de la partitura <br>

     * y al espacio vertical que se debe dejar entre las notas

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @return La coordenada en y de la nota

     */

    protected int calcularCoordenadaYNota( int posicion )

    {

        int coordenadaY;



        coordenadaY = ( darPosicionNotaPentagrama( ) ) * ESPACIO_NOTAS_VERTICAL + Partitura.MARGEN_PARTITURA_EXTERNA + ( Partitura.MARGEN_PARTITURA_INTERNA * 3 / 4 );



        if( ( posicion + 2 ) * ESPACIO_NOTAS_HORIZONTAL > Partitura.ANCHO_PARTITURA ) // Si ya se lleno la primera partitura se pasa a la siguiente

        {

            coordenadaY = coordenadaY + Partitura.MARGEN_PARTITURA_INTERNA / 2 + Partitura.ESPACIO_LINEAS_PENTAGRAMA * 5;

        }



        return coordenadaY;

    }



    /**

     * Retorna un valor numérico correspondiente a la posición de la nota en el pentagrama: <br>

     * 11 para DO, 10 para RE, 9 para MI, 8 para FA, 7 para SOL, 6 para LA, 5 para SI, 4 para DO2

     * @return Posición de la nota en el pentagrama de la nota

     */

    public int darPosicionNotaPentagrama( )

    {

        int val;



        if( nombre.equalsIgnoreCase( DO ) )

        {

            val = 11;

        }

        else if( nombre.equalsIgnoreCase( RE ) )

        {

            val = 10;

        }

        else if( nombre.equalsIgnoreCase( MI ) )

        {

            val = 9;

        }

        else if( nombre.equalsIgnoreCase( FA ) )

        {

            val = 8;

        }

        else if( nombre.equalsIgnoreCase( SOL ) )

        {

            val = 7;

        }

        else if( nombre.equalsIgnoreCase( LA ) )

        {

            val = 6;

        }

        else if( nombre.equalsIgnoreCase( SI ) )

        {

            val = 5;

        }

        else

        {

            val = 4; // DO2

        }



        return val;



    }



    /**

     * Sirve para saber si un punto está dentro de la nota o no.

     * @param px Es la coordenada x del punto

     * @param py Es la coordenada y del punto

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @return Retorna true si el punto está dentro de la nota. Retorna false en caso contrario.

     */

    public boolean estaDentro( int px, int py, int posicion )

    {

        int cX = calcularCoordenadaXNota( posicion );

        int cY = calcularCoordenadaYNota( posicion );

        int ancho = tipo == NORMAL ? ANCHO_NOTA : ESPACIO_NOTAS_HORIZONTAL;

        Rectangle2D rectangulo = new Rectangle2D.Double( cX, cY, ancho, ALTO_NOTA );



        return rectangulo.contains( px, py );

    }



    /**

     * Modifica el tipo de la nota

     * @param t nuevo tipo de la nota

     */

    public void cambiarTipo( String t )

    {

        tipo = t;

        verificarInvariante( );

    }



    /**

     * Cambia el color de la nota

     * @param c Nuevo color de la nota

     */

    public void cambiarColor( Color c )

    {

        color = c;

        verificarInvariante( );

    }



    /**

     * Cambia el nombre de la nota

     * @param nom Nuevo nombre de la nota

     */

    public void cambiarNombre( String nom )

    {

        nombre = nom;

        verificarInvariante( );



    }



    /**

     * Retorna el color de la nota

     * @return Color de la nota

     */

    public Color darColor( )

    {

        return color;

    }



    /**

     * Indica si la nota es igual al objeto o

     * @param o Nota con la que se va a ser la comparación

     */

    public boolean equals( Object o )

    {

        Nota aux = ( Nota )o;

        return aux.darClase( ).equals( darClase( ) ) && aux.color.equals( color ) && aux.nombre.equals( nombre ) && aux.tipo.equals( tipo );

    }



    /**

     * Inicializa el color de la nota a partir de la información que estaba contenida en el archivo <br>

     * <b>post: </b> color tiene nuevo color

     * @param lineaColor La línea de texto que indica el color de la nota

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato de la línea no es el esperado

     */

    private void inicializarColor( String lineaColor ) throws FormatoInvalidoExcepcion

    {



        String[] strValoresFondo = lineaColor.split( ";" );



        if( strValoresFondo.length != 3 )

            throw new FormatoInvalidoExcepcion( lineaColor );



        try

        {

            int r1 = Integer.parseInt( strValoresFondo[ 0 ] );

            int g1 = Integer.parseInt( strValoresFondo[ 1 ] );

            int b1 = Integer.parseInt( strValoresFondo[ 2 ] );



            color = new Color( r1, g1, b1 );

        }

        catch( NumberFormatException nfe )

        {

            throw new FormatoInvalidoExcepcion( lineaColor );

        }



    }



    /**

     * Este método sirve para guardar la nota en un archivo

     * @param out Es el stream donde se va a guardar la nota

     */

    public void guardar( PrintWriter out )

    {

        out.println( darClase( ) );

        out.println( darTipo( ) );

        out.println( darNombre( ) );

        out.println( color.getRed( ) + ";" + color.getGreen( ) + ";" + color.getBlue( ) );

    }



    // -----------------------------------------------------------------

    // Invariante

    // -----------------------------------------------------------------



    /**

     * Verifica el invariante de la clase. <br>

     * <b>inv: </v> <br>

     * (tipo= Sostenido o tipo= Normal) y (nombre= DO o nombre= RE o nombre= MI o nombre= FA o nombre= SOL o nombre= LA o nombre= SI o nombre= DO2)<br>

     * 

     */

    protected void verificarInvariante( )

    {

        assert ( nombre.equalsIgnoreCase( DO ) || nombre.equalsIgnoreCase( RE ) || nombre.equalsIgnoreCase( MI ) || nombre.equalsIgnoreCase( FA ) || nombre.equalsIgnoreCase( SOL ) || nombre.equalsIgnoreCase( LA ) || nombre.equalsIgnoreCase( SI ) || nombre

                .equalsIgnoreCase( DO2 ) ) : "El nombre de nota " + nombre + " no existe";

        assert ( tipo.equalsIgnoreCase( SOSTENIDO ) || tipo.equalsIgnoreCase( NORMAL ) ) : "El tipo de nota " + tipo + " no existe";

    }

}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 * $Id: Partitura.java 604 2006-11-07 04:47:33Z da-romer $ 

 * 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: n10_partitura

 * Autor: Diana Puentes - Jul 29, 2005

 * Modificado por: Daniel Francisco Romero Acero- Marzo 23, 2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

 */



package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics2D;

import java.awt.image.BufferedImage;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.ArrayList;



import javax.imageio.ImageIO;



/**

 * Esta es una clase que representa una partitura musical. <br>

 * <b>inv: </b> <br>

 * notas != null <br>

 * notas.size <= NUM_MAX_NOTAS <br>

 */

public class Partitura

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    

    public static final int ESPACIO_LINEAS_PENTAGRAMA = 12;



    public static final int ANCHO_PARTITURA = 1010;



    public static final int ALTO_PARTITURA = 313;



    public static final int MARGEN_PARTITURA_INTERNA = 92;



    public static final int MARGEN_PARTITURA_EXTERNA = 12;



    public static final String ARCHIVO_IMAGEN_CLAVE_SOL = "claveSol.GIF";



    public static final int ALTO_IMAGEN_CLAVE_SOL = 79;



    public static final int ANCHO_IMAGEN_CLAVE_SOL = 47;



    public static final int NUM_MAX_NOTAS = 60;



    // -----------------------------------------------------------------

    // Atributos

    // -----------------------------------------------------------------



    /**

     * Representa el conjunto de notas de la canción de la partitura

     */

    private ArrayList notas;



    /**

     * El título de la partitura

     */

    private String titulo;



    /**

     * El tipo de letra del título de la partitura

     */

    private Font fuenteTitulo;



    /**

     * El color del título de la partitura

     */

    private Color colorTitulo;



    /**

     * Posición de la nota marcada (que se está tocando actualmente)

     */

    private int posicionNotaMarcada;



    /**

     * Es el archivo donde se está salvando actualmente la partitura

     */

    private String archivo;



    /**

     * La figura de la clave de sol

     */

    private BufferedImage figuraClaveSol;



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Crea una nueva partitura vacía

     */

    public Partitura( )

    {

        notas = new ArrayList( );

        titulo = "";

        fuenteTitulo = new Font( "Arial", Font.PLAIN, 10 );

        colorTitulo = Color.BLACK;

        cargarImagen( ARCHIVO_IMAGEN_CLAVE_SOL );

        posicionNotaMarcada = -1;

    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------

    /**

     * Carga la imagen con el nombre especificado

     * @param imagen Nombre de la imagen a ser cargada

     */

    private void cargarImagen( String imagen )

    {

        try

        {

            figuraClaveSol = ImageIO.read( new File( "data\\" + imagen ) );

        }

        catch( IOException e )

        {

            figuraClaveSol = new BufferedImage( 1, 1, BufferedImage.TYPE_INT_RGB );

        }

    }



    /**

     * Carga la partitura que se encuentra en el archivo dado por la ruta <br>

     * <b>Pre: </b> La partitura puede tener máximo 40 notas <br>

     * <b>Post: </b> Almacena los datos de la partitura en el ArrayList notas <br>

     * @param nombreArchivo - La ruta del archivo que contiene la partitura

     * @return La lista de las notas cargadas en la partitura

     * @throws IOException Se lanza esta excepción si alguna de las líneas es inválida o si no se encuentra el archivo a cargar

     */

    public void abrir( String nombreArchivo ) throws FormatoInvalidoExcepcion, IOException

    {

        ArrayList notasAnteriores = new ArrayList( );



        // Cargar las notas

        BufferedReader br = new BufferedReader( new FileReader( nombreArchivo ) );

        String linea = br.readLine( );

        try

        {

            titulo = linea;

            linea = br.readLine( );

            inicializarColorTitulo( linea );

            linea = br.readLine( );

            inicializarFuente( linea );



            // Salvar las notas anteriores por si se presenta algun error

            notasAnteriores.addAll( notas );



            // Eliminar las notas anteriores

            notas.clear( );



            // Crear las notas

            linea = br.readLine( );

            int cuantasNotas = Integer.parseInt( linea );

            for( int i = 0; i < cuantasNotas; i++ )

            {

                linea = br.readLine( );

                crearNota( linea, br );

            }



            br.close( );

        }

        catch( NumberFormatException nfe )

        {

            br.close( );

            notas.clear( );

            notas.addAll( notasAnteriores );

            throw new FormatoInvalidoExcepcion( linea );

        }



        // Reemplazar el nombre de archivo viejo

        archivo = nombreArchivo;



        verificarInvariante( );



    }



    /**

     * Salva la partitura actual en el archivo que se venía usando. <br>

     * <b>pre: </b> Hay un archivo para salvar ya establecido. <br>

     * <b>post: </b> Se salvó la partitura en un archivo.

     * @throws IOException Se lanza esta excepción si hay problemas salvando la partitura

     */

    public void salvar( ) throws IOException

    {

        PrintWriter out = new PrintWriter( archivo );

        out.println( titulo );

        out.println( "" + colorTitulo.getRed( ) + ";" + colorTitulo.getGreen( ) + ";" + colorTitulo.getBlue( ) );

        out.println( "" + fuenteTitulo.getFamily( ) + ";" + fuenteTitulo.getStyle( ) + ";" + fuenteTitulo.getSize( ) );

        out.println( notas.size( ) );



        // Guardar las notas de la partitura

        for( int cont = 0; cont < notas.size( ); cont++ )

        {

            INota n = ( Nota )notas.get( cont );

            n.guardar( out );

        }



        out.close( );

    }



    /**

     * Salva la partitura actual en el archivo especificado. <br>

     * <b>post: </b> Se salvó la partitura en un archivo.

     * @param nombreArchivo Es el nombre del archivo donde se va a salvar la partitura

     * @throws IOException Se lanza esta excepción si hay problemas salvando la partitura

     */

    public void salvar( String nombreArchivo ) throws IOException

    {

        archivo = nombreArchivo;

        salvar( );

    }



    /**

     * Inicializa el color del título a partir de la información que estaba contenida en el archivo <br>

     * <b>post: </b> colorTitulo tiene nuevo color

     * @param lineaColorTitulo La línea de texto que indica el color del titulo de la partitura

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato de la línea no es el esperado

     */

    private void inicializarColorTitulo( String lineaColorTitulo ) throws FormatoInvalidoExcepcion

    {



        String[] strValoresFondo = lineaColorTitulo.split( ";" );



        if( strValoresFondo.length != 3 )

            throw new FormatoInvalidoExcepcion( lineaColorTitulo );



        try

        {

            int r1 = Integer.parseInt( strValoresFondo[ 0 ] );

            int g1 = Integer.parseInt( strValoresFondo[ 1 ] );

            int b1 = Integer.parseInt( strValoresFondo[ 2 ] );



            colorTitulo = new Color( r1, g1, b1 );

        }

        catch( NumberFormatException nfe )

        {

            throw new FormatoInvalidoExcepcion( lineaColorTitulo );

        }



    }



    /**

     * Inicializa la fuente usada para mostrar el título de la partitura <br>

     * <b>post: </b> fuenteTitulo tiene una nueva fuente de texto

     * @param lineaFuente La línea de texto que describe la fuente usada en el texto de la partitura

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato de la línea no es el esperado

     */

    private void inicializarFuente( String lineaFuente ) throws FormatoInvalidoExcepcion

    {

        String[] strFuente = lineaFuente.split( ";" );



        if( strFuente.length != 3 )

            throw new FormatoInvalidoExcepcion( lineaFuente );



        try

        {

            String nomFuente = strFuente[ 0 ];

            int estilo = Integer.parseInt( strFuente[ 1 ] );

            int tam = Integer.parseInt( strFuente[ 2 ] );



            fuenteTitulo = new Font( nomFuente, estilo, tam );

        }

        catch( NumberFormatException nfe )

        {

            throw new FormatoInvalidoExcepcion( lineaFuente );

        }

    }



    /**

     * Crea una nota con los datos contenidos en un archivo y la adiciona a la lista respectiva

     * @param claseNota Es la cadena que identifica la clase de nota que se debe construir (redonda, blanca, negra, corchea o semicorchea)

     * @param br Es el stream de donde se pueden leer los datos para crear la nota - br!=null

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el archivo tiene un formato incorrecto

     * @throws IOException Se lanza esta excepción si hay problemas leyendo del archivo

     */

    private void crearNota( String claseNota, BufferedReader br ) throws FormatoInvalidoExcepcion, IOException

    {

        INota nueva = null;



        if( "REDONDA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Redonda( br );

        }

        else if( "BLANCA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Blanca( br );

        }

        else if( "NEGRA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Negra( br );

        }

        else if( "CORCHEA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Corchea( br );

        }

        else if( "SEMICORCHEA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Semicorchea( br );

        }

        else

        {

            br.close( );

            throw new FormatoInvalidoExcepcion( claseNota );

        }



        notas.add( nueva );

    }



    /**

     * Crea una nota con los datos especificados

     * @param claseNota Es la cadena que identifica la clase de nota que se debe construir <br>

     *        (redonda, blanca, negra, corchea o semicorchea)

     * @param nombre Nombre de la nota (do, re, mi, fa, sol, la, si, do2)

     * @param tipo El tipo de la nota (normal o sostenido)

     * @param color El color de la nota

     * @return Nueva nota. En el caso de que claseNota no corresponda a ninguna clase de nota se retorna null

     */

    public INota crearNota( String claseNota, String nombre, String tipo, Color color )

    {

        INota nueva = null;



        if( "REDONDA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Redonda( nombre, tipo, color );

        }

        else if( "BLANCA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Blanca( nombre, tipo, color );

        }

        else if( "NEGRA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Negra( nombre, tipo, color );

        }

        else if( "CORCHEA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Corchea( nombre, tipo, color );

        }

        else if( "SEMICORCHEA".equalsIgnoreCase( claseNota ) )

        {

            nueva = new Semicorchea( nombre, tipo, color );

        }



        return nueva;

    }



    /**

     * Retorna el conjunto de notas de la partitura

     * @return Una lista con las notas que componen la canción escrita en la partitura

     */

    public ArrayList darNotas( )

    {

        return notas;

    }



    /**

     * Sirve para pintar la partitura con todas las notas que contiene

     * @param g La superficie donde se debe pintar

     */

    public void pintarPartitura( Graphics2D g )

    {

        INota nota;



        // Pintar el fondo blanco

        g.setColor( Color.WHITE );

        g.fillRect( MARGEN_PARTITURA_EXTERNA, MARGEN_PARTITURA_EXTERNA, ANCHO_PARTITURA, ALTO_PARTITURA );



        // Pintar el título de la partitura

        pintarTitulo( g );



        // Pintar las notas

        for( int cont = 0; cont < notas.size( ); cont++ )

        {

            nota = ( INota )notas.get( cont );



            if( posicionNotaMarcada != cont )

            {

                nota.pintarNota( g, cont );

            }

            else

            {

                nota.pintarNotaMarcada( g, cont );

            }



        }



        // Pintar las líneas del pentagrama- parte superior

        pintarPentagrama( MARGEN_PARTITURA_INTERNA, g );



        // Pintar las líneas del pentagrama- parte inferior

        pintarPentagrama( MARGEN_PARTITURA_INTERNA + MARGEN_PARTITURA_INTERNA / 2 + ESPACIO_LINEAS_PENTAGRAMA * 5, g );



    }



    /**

     * Pinta el título de la partitura

     * @param g La superficie donde se debe pintar

     */

    public void pintarTitulo( Graphics2D g )

    {

        int posX = ( ANCHO_PARTITURA + MARGEN_PARTITURA_EXTERNA * 2 ) / 2;

        int posY = MARGEN_PARTITURA_EXTERNA + MARGEN_PARTITURA_INTERNA / 3;



        g.setFont( fuenteTitulo );

        g.setColor( colorTitulo );



        FontMetrics metrics = g.getFontMetrics( );

        int ancho = metrics.stringWidth( titulo );



        g.drawString( titulo, posX - ancho / 2, posY );



    }



    /**

     * Pinta un pentagrama iniciando desde la posición en Y especificada

     * @param posY Posición en Y desde la que se va a empezar a pintar el pentagrama

     * @param g La superficie donde se debe pintar

     */

    public void pintarPentagrama( int posY, Graphics2D g )

    {

        g.setColor( Color.BLACK );



        int posYActual = posY;



        // Pintar las líneas

        for( int cont = 0; cont < 5; cont++ )

        {

            g.drawLine( MARGEN_PARTITURA_EXTERNA, posYActual, ANCHO_PARTITURA, posYActual );



            posYActual += ESPACIO_LINEAS_PENTAGRAMA;

        }



        // Pintar la clave de sol

        pintarClaveSol( posY - ESPACIO_LINEAS_PENTAGRAMA, g );

    }



    /**

     * Carga de una imagen la clave de sol

     * @param posY Posición en y desde la que se va localizar la imagen de la clave de sol

     * @param g La superficie donde se debe pintar

     */

    public void pintarClaveSol( int posY, Graphics2D g )

    {

        g.drawImage( figuraClaveSol, MARGEN_PARTITURA_EXTERNA, posY, ANCHO_IMAGEN_CLAVE_SOL, ALTO_IMAGEN_CLAVE_SOL, Color.WHITE, null );

    }



    /**

     * Elimina las notas de la partitura

     * 

     */

    public void eliminarNotas( )

    {

        notas.clear( );

    }



    /**

     * Modifica el titulo de la partitura

     * @param nT Nuevo titulo de la partitura

     */

    public void cambiarTitulo( String nT )

    {

        titulo = nT;

    }



    /**

     * Retorna el nombre del archivo donde se está guardando la información de este mapa

     * @return archivo. Si no se ha establecido todavía el nombre del archivo, retorna null.

     */

    public String darNombreArchivo( )

    {

        return archivo;

    }



    /**

     * Retorna la fuente del titulo de la partitura

     * @return Fuente del titulo de la partitura

     */

    public Font darFuenteTitulo( )

    {

        return fuenteTitulo;

    }



    /**

     * Retorna el título de la partitura

     * @return Título de la partitura

     */

    public String darTitulo( )

    {



        return titulo;

    }



    /**

     * Cambia la fuente del título

     * @param fuente Nueva fuente del título

     */

    public void cambiarFuenteTitulo( Font fuente )

    {

        fuenteTitulo = fuente;



    }



    /**

     * Cambia el color del título

     * @param color Nuevo color del título

     */

    public void cambiarColorTitulo( Color color )

    {

        colorTitulo = color;



    }



    /**

     * Retorna el color del título de la partitura

     * @return Retorna el color del título

     */

    public Color darColorTitulo( )

    {



        return colorTitulo;

    }



    /**

     * Retorna la posición de la nota que contiene los puntos especificados

     * @param x Punto x que debe contener la nota

     * @param y Punto y que debe contener la nota

     * @return Posición de la nota que contiene los dos puntos especificados. <br>

     *         Si ninguna nota contiene los puntos especificados se retorna -1.

     * 

     */

    public int buscarNota( int x, int y )

    {

        INota nota = null;

        int pos = -1;



        boolean encontrada = false;



        // Buscar la construcción

        for( int cont = 0; cont < notas.size( ) && !encontrada; cont++ )

        {

            nota = ( Nota )notas.get( cont );



            if( nota.estaDentro( x, y, cont ) )

            {

                encontrada = true;

                pos = cont;

            }



        }

        return pos;

    }



    /**

     * Elimina la nota en la posición especificada

     * @param posNota Posición de la nota a ser eliminada

     */

    public void eliminarNota( int posNota )

    {



        if( posNota >= 0 && posNota < notas.size( ) )

        {

            notas.remove( posNota );

            verificarInvariante( );

        }



    }



    /**

     * Cambia la información de la nota correspondiente a la posición especificada. <br>

     * En el caso de que la clase de la nota haya cambiado la elimina y la vuelve a crear

     * @param clase La clase de la nota (redonda, blanca, negra, corchea, semicorchea)

     * @param tipo El tipo de la nota (normal o sostenido)

     * @param color El color de la nota

     * @param posicion La posición de la nota a ser modificada

     * @param nombre El nombre de la nota (do, re mi, fa sol, la, si, do2)

     */

    public void cambiarInformacionNota( String clase, String tipo, Color color, int posicion, String nombre )

    {

        INota nota = ( INota )notas.get( posicion );



        if( clase.equalsIgnoreCase( nota.darClase( ) ) )

        {

            nota.cambiarColor( color );

            nota.cambiarTipo( tipo );

            nota.cambiarNombre( nombre );

        }

        else

        {

            nota = crearNota( clase, nombre, tipo, color );

            eliminarNota( posicion );

            notas.add( posicion, nota );

        }



    }



    /**

     * Retorna la nota en la posición especificada

     * @param pos Posición de la nota a ser retorna

     * @return Nota en la posición especificada. Se retornó null si no existe una nota en la posición dada

     */

    public INota darNota( int pos )

    {

        INota n = null;



        if( pos >= 0 && pos < notas.size( ) )

        {

            n = ( INota )notas.get( pos );

        }



        return n;

    }



    /**

     * Modifica la nota marcada

     * @param pos Posición de la nota marcada

     */

    public void cambiarNotaMarcada( int pos )

    {

        posicionNotaMarcada = pos;



    }



    /**

     * Adiciona la nota especificada a la partitura si aún no se ha excedido el número máximo permitido

     * @param n Nueva nota a ser adicionada

     */

    public void adicionarNota( INota n )

    {

        if( notas.size( ) < NUM_MAX_NOTAS )

        {

            notas.add( n );

        }



    }



    /**

     * Verifica que la nota tocada es la correcta

     * @param nota Nota ser tocada

     * @param posicionActual Posición actual que se está tocando

     * @return True si la nota es correcta, false de lo contrario

     */

    public boolean verificarNota( INota nota, int posicionActual )

    {

        boolean correcta = false;



        if( posicionActual >= 0 && posicionActual < notas.size( ) )

        {

            INota aux = ( INota )notas.get( posicionActual );



            if( aux.equals( nota ) )

                correcta = true;

        }



        return correcta;

    }



    /**

     * Retorna la posición de la nota que se encuentra marcada actualmente

     * @return Posición de la nota marcada

     */

    public int darPosicionNotaMarcada( )

    {

        return posicionNotaMarcada;

    }



    // -----------------------------------------------------------------

    // Invariante

    // -----------------------------------------------------------------

    /**

     * Verifica el invariante de la clase. <br>

     * <b>inv: </v> <br>

     * notas != null <br>

     * notas.size <= NUM_MAX_NOTAS <br>

     */

    public void verificarInvariante( )

    {

        assert ( notas != null ) : "La lista de notas no puede ser null";

        assert ( notas.size( ) <= NUM_MAX_NOTAS ) : "La cantidad de notas excede el número máximo de notas permitido";

    }



    // -----------------------------------------------------------------

    // Puntos de Extensión

    // -----------------------------------------------------------------



    /**

     * Ejecuta el punto de extensión 1

     * @return respuesta1

     */

    public String metodo1( )

    {

        return "respuesta1";

    }



    /**

     * Ejecuta el punto de extensión 2

     * @return respuesta2

     */

    public String metodo2( )

    {

        return "respuesta2";

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: Redonda.java 600 2006-11-06 06:16:53Z da-romer $

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 21-marzo-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.BufferedReader;

import java.io.IOException;



/**

 * Esta es una clase que representa una redonda en la partitura

 */

public class Redonda extends Nota

{

    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    public static final int DURACION = 4;

    public static final String CLASE = "Redonda";



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una redonda

     * @param nom El nombre de la redonda

     * @param tip El tipo de la redonda

     * @param co Color de la redonda

     */

    public Redonda( String nom, String tip, Color co )

    {

        super( nom, tip, co );



    }



    /**

     * Crea la redonda a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Redonda( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {

        super( br );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------



    /**

     * Retorna la duración de la nota

     */

    public double darDuracion( )

    {

        return DURACION;

    }



    /**

     * Retorna la clase de la nota

     */

    public String darClase( )

    {

        return CLASE;

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected void pintar( Graphics2D g, int posicion, Color c )

    {

        g.setColor( c );

        int coordenadaX = calcularCoordenadaXNota( posicion );

        int coordenadaY = calcularCoordenadaYNota( posicion );



        g.drawOval( coordenadaX, coordenadaY, ANCHO_NOTA, ALTO_NOTA );



        // Si la nota es DO se debe pintar la línea que atraviesa la nota

        if( nombre.equalsIgnoreCase( DO ) )

        {

            g.drawLine( coordenadaX - 5, coordenadaY + ALTO_NOTA / 2, coordenadaX + ANCHO_NOTA + 5, coordenadaY + ALTO_NOTA / 2 );

        }



        pintarSostenido( g, posicion, c );

    }



}


/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * $Id: Semicorchea.java 600 2006-11-06 06:16:53Z da-romer $

 * 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: n10_partitura

 * Autor: Daniel Francisco Romero Acero - 21-marzo-2006

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */

package uniandes.cupi2.partitura.mundo;



import java.awt.Color;

import java.awt.Graphics2D;

import java.io.BufferedReader;

import java.io.IOException;



/**

 * Esta es una clase que representa una semicorchea en la partitura

 */

public class Semicorchea extends Nota

{



    // -----------------------------------------------------------------

    // Constantes

    // -----------------------------------------------------------------

    public static final double DURACION = 0.25;



    public static final String CLASE = "Semicorchea";



    // -----------------------------------------------------------------

    // Constructores

    // -----------------------------------------------------------------



    /**

     * Construye una semicorchea

     * @param nom El nombre de la corchea

     * @param tip El tipo de la corchea

     * @param co Color de la corchea

     */

    public Semicorchea( String nom, String tip, Color co )

    {

        super( nom, tip, co );



    }



    /**

     * Crea la semicorchea a partir de los datos contenidos en un archivo

     * @param br Es el stream que sirve para leer el archivo

     * @throws IOException Se lanza esta excepción si hay problemas leyendo el archivo

     * @throws FormatoInvalidoExcepcion Se lanza esta excepción si el formato del archivo no es el esperado

     */

    public Semicorchea( BufferedReader br ) throws IOException, FormatoInvalidoExcepcion

    {

        super( br );



    }



    // -----------------------------------------------------------------

    // Métodos

    // -----------------------------------------------------------------

    /**

     * Retorna la duración de la nota

     */

    public double darDuracion( )

    {

        return DURACION;

    }



    /**

     * Retorna la clase de la nota

     */

    public String darClase( )

    {

        return CLASE;

    }



    /**

     * Sirve para pintar la nota del color dado

     * @param g La superficie donde se debe pintar

     * @param posicion La posición de la nota dentro de la partitura a la que pertenece

     * @param c El color con el que se va a pintar la nota

     */

    protected void pintar( Graphics2D g, int posicion, Color c )

    {

        // Pintar el circulo

        g.setColor( c );

        int coordenadaX = calcularCoordenadaXNota( posicion );

        int coordenadaY = calcularCoordenadaYNota( posicion );



        g.fillOval( coordenadaX, coordenadaY, ANCHO_NOTA, ALTO_NOTA );



        // Pintar la línea

        int coordenadaXLinea = calcularCoordenadaXNota( posicion ) + ANCHO_NOTA;

        int coordenadaYLinea = calcularCoordenadaYNota( posicion ) + ALTO_NOTA / 2;



        g.drawLine( coordenadaXLinea, coordenadaYLinea, coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA );



        // Pintar la primera línea de la semicorchea

        g.drawLine( coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA, coordenadaXLinea + 5, coordenadaYLinea - ALTO_LINEA_NOTA + 5 );



        // Pintar la segunda línea de la semicorchea

        g.drawLine( coordenadaXLinea, coordenadaYLinea - ALTO_LINEA_NOTA + 5, coordenadaXLinea + 5, coordenadaYLinea - ALTO_LINEA_NOTA + 10 );



        // Si la nota es DO se debe pintar la línea que atraviesa la nota

        if( nombre.equalsIgnoreCase( DO ) )

        {

            g.drawLine( coordenadaX - 5, coordenadaY + ALTO_NOTA / 2, coordenadaX + ANCHO_NOTA + 5, coordenadaY + ALTO_NOTA / 2 );

        }



        pintarSostenido( g, posicion, c );

    }



}

Interfaz
	BarraMenu
	DialogoInformacionNota
	DialogoTituloPartitura
	InterfazPartitura
	PanelModificarInformacionNota
	PanelModificarTitulo
	PanelOpciones
	PanelPartitura
	PanelTeclado
	PopupMenuNota
	ReproductorNota

Mundo
	Blanca
	Corchea
	FormatoInvalidoExcepcion
	INota
	Negra
	Nota
	Partitura
	Redonda
	Semicorchea