Modelos da Aplicação

A classe principal que controla a aplicação é a StringlessGuitarUI. Ela contém as variáveis de instância que representam os botões para cada acorde de um tom. No diagrama coloquei apenas uma para servir de exemplo. Logo abaixo, a classe ButtonHandler, onde se encontra a lógica de abertura de um arquivo áudio, é interna da StringlessGuitarUI. Ela é marcada com um + dentro de um círculo ligados por uma seta.

A ButtonFactory é uma classe que encapsula a instanciação de todos os botões da tela. ButtonHandler implementa uma interface ouvinte de eventos de clique em um botão - ActionListener. Destaquei o método que realiza essa operação:



public void actionPerformed(ActionEvent e) {
           InputStream in;
           if(e.getSource() == buttonEm_CMaior){
           try{
                in = new FileInputStream(new File("C:\\Users\\Thiago\\Downloads\\Em_C Maior.wav"));
                AudioStream audios = new AudioStream(in);
                AudioPlayer.player.start(audios);
              }
           catch(Exception ex){
                JOptionPane.showMessageDialog(null, ex);
           }
      }

Um destaque para a interação do usuário com a máquina, ao clicar em um botão. O evento actionPerformed é disparado para a classe que o tratará (ButtonHandler):

A classe InputStream instancia um objeto da classe FileInputStream, que passa como argumento um path de um arquivo áudio (no momento em que actionPerformed é executado). Logo, a classe AudioInputStream instancia um objeto da própria classe e este recebe como argumento o path do arquivo, criando uma dependência de parâmetros.

Prévia da Interface Gráfica: Stringless Guitar - Parte 3

Nessa parte iremos abordar sobre os tratadores de evento de selecionar um item do JComboBox. Ao consultar a documentação (API), descobrimos como prosseguir diante desta situação. Há dois métodos de duas interfaces distintas, respectivamente, ActionListener e ItemListener, que podem ser associados a um JComboBox. Devemos, portanto, criar uma classe que implemente uma dessas interfaces, e instanciar um objeto que será registrado como o handler de evento.

Ambos funcionam, mas é preciso ressaltar a diferença de comportamento entre ambos. Para cada item selecionado, a seleção de outro item é primeiro removida - então ocorrem dois ItemEvents quando um item é selecionado. Ou seja, quando você selecionar um item, este método (itemStateChanged) será disparado duas vezes, ficando propensa a ocorrência de futuros bugs.

Então, optamos por utilizar um action listener. As duas condições dentro do método actionPerformed determinam a origem do evento (se ele é oriundo da primeira ou segunda combo box). 

void addActionListener(ActionListener) : Adiciona um action listener ao combo box. O método actionPerformed do listener é chamado quando o usuário seleciona um item do combo box ou, quando num combo box editável, quando o usuário pressiona Enter.

void addItemListener(ItemListener) : Adiciona um item listener ao combo box. O método itemStateChanged do listener é chamado quando o estado de seleção de qualquer um dos combo box's muda.

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

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


public class TesteEventoJComboBox extends JFrame implements ActionListener {

JComboBox comboBoxTomMenor;
JComboBox comboBoxTomMaior;

public TesteEventoJComboBox(){
super("Teste Evento JComboBox");
Container container = this.getContentPane();
container.setLayout(new FlowLayout());

String[] listaAfinacaoMaior = {"Selecione um tom maior","C", "Db", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B"};
String[] listaAfinacaoMenor = {"Selecione um tom menor","C", "C#", "D", "Eb", "E", "F", "F#", "G", "G#", "A", "Bb", "B"};

comboBoxTomMaior = new JComboBox(listaAfinacaoMaior);
container.add(comboBoxTomMaior);

comboBoxTomMenor = new JComboBox(listaAfinacaoMenor);
container.add(comboBoxTomMenor);

comboBoxTomMaior.setEditable(false);
comboBoxTomMenor.setEditable(false);

comboBoxTomMaior.addActionListener(this);
comboBoxTomMenor.addActionListener(this);
}


public static void main(String[] args) {
TesteEventoJComboBox t = new TesteEventoJComboBox();
t.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
t.setSize(250, 150);
t.setVisible(true);
}


@Override
public void actionPerformed(ActionEvent event) {
if(event.getSource() == comboBoxTomMaior){
JOptionPane.showMessageDialog(null, String.format("Você clicou %s", comboBoxTomMaior.getSelectedItem()));
}

if(event.getSource() == comboBoxTomMenor) {
JOptionPane.showMessageDialog(null, String.format("Você clicou %s", comboBoxTomMenor.getSelectedItem()));
}
}

}

Fontes de Referência

DEITEL, H.M; DEITEL, P.J, Java, Como Programar -8ªed. – São Paulo: Prentice Hall, 2010.

http://geekycoder.wordpress.com/2008/07/28/tipjava-difference-between-actionlistener-and-itemlistener/

http://javafree.uol.com.br/topic-864599-JComboBox-eventos-duplicados.html

http://docs.oracle.com/javase/tutorial/uiswing/components/combobox.html#listeners

Interface Gráfica: Primeiro Esboço

Hoje nos reunimos para tratar algumas pendências do nosso projeto de Iniciação Científica. Fizemos um levantamento detalhado dos materiais comprados e os que ainda faltam adquirir (veja aqui). Discutimos sobre duas ideias de interface gráfica, ora que a pesquisa induz às possibilidades. 

Os objetivos desta parte da pesquisa consistem em construir uma interface gráfica para um leigo na música que deseja conhecer os sons das notas musicais de todas as afinações de uma guitarra. Separadamente, pretendemos verificar a viabilidade de utilizar o Arduino para afinar as notas da guitarra do nosso projeto.

A figura abaixo refere-se a um rascunho de uma tela feita em Java com Swing. A API Swing procura desenhar por conta própria todos os componentes, como formulários, botões, ícones, dentre outros; ao invés de delegar essa tarefa ao sistema operacional, como a maioria das outras APIs de interface gráfica trabalham. O propósito aqui é de criar botões correspondentes à cada nota musical. Quando o usuário clicar em um deles, o resultado será o som daquela nota. O primeiro teste será com a afinação padrão. Depois, montaremos uma lista com todas as afinações existentes ao canto da tela.

Elaboramos um roteiro de pesquisa da tecnologia que utilizaremos na interface. Os próximos, da parte física, serão carregados em breve.

Roteiro (outubro-dezembro/2012)

- Ler a documentação da API JavaSound e começar a testar (aos poucos);

- Testar exemplos do livro Java: Use A Cabeça e dos sites relacionados;

- Aprender a criar telas no swing;
- Pesquisar sobre tons/escalas musicais e também formatos de mídia (os que são compatíveis com a API JavaSound);

- Verificar a possibilidade de utilizar o pacote javax.media junto com o Swing, para facilitar a programação (http://javafree.uol.com.br/topic-857802-exemplo-para-quem-quer-tocar-mp3-em-java.html);

Fontes de Referência: sites

//JavaSound Documentação, Links, etc

http://www.oracle.com/technetwork/java/javasounddemo-140014.html

http://www.oracle.com/technetwork/java/links-142934.html

http://docs.oracle.com/javase/1.4.2/docs/guide/sound/programmer_guide/chapter11.html#124620

http://www.jsresources.org/examples/SimpleMidiPlayer.html

http://stackoverflow.com/questions/5291725/java-sound-api-initialization?rq=1

//Swing
http://docs.oracle.com/javase/tutorial/uiswing/TOC.html#learn

//exemplos com JMF - depois

http://www.javaworld.com/javaworld/jw-04-2001/jw-0406-jmf1.html

http://www.javaworld.com/javaworld/jw-05-2001/jw-0504-jmf2.html?page=1

http://docs.oracle.com/cd/E17802_01/j2se/javase/technologies/desktop/media/jmf/2.1.1/apidocs/
http://www.oracle.com/technetwork/java/javase/documentation/index-135173.html

//opcional – estender javasound para mp3

http://onjava.com/pub/a/onjava/2004/08/11/javasound-mp3.html