import br.ufpe.cin.miniJava.exception.InvalidConversionException;
import br.ufpe.cin.miniJava.gui.Button;
import br.ufpe.cin.miniJava.gui.Component;
import br.ufpe.cin.miniJava.gui.Label;
import br.ufpe.cin.miniJava.gui.TextField;
import br.ufpe.cin.miniJava.gui.Window;
import br.ufpe.cin.miniJava.util.MiniJavaSystem;
public class MinhaJanelaComExcecao extends Window {
Button botaoCalcular;
Button botaoSaida;
TextField campoEntrada;
TextField campoResultado;
MinhaJanelaComExcecao(String titulo) {
Label rotuloEntrada;
Label rotuloResultado;
botaoCalcular = this.criarBotao("Calc", 250, 65);
botaoSaida = this.criarBotao("Sair", 360, 65);
campoEntrada = this.criarCampo(100,60);
campoResultado = this.criarCampo(100, 90);
rotuloEntrada = new Label("Entrada");
rotuloResultado = new Label("Resultado");
this.include(rotuloEntrada,40,60);
this.include(rotuloResultado,40,90);
this.setTitle(titulo);
this.setSize(500,400);
}
private TextField criarCampo(int x, int y) {
TextField campo = new TextField();
this.include(campo,x,y);
return campo;
}
private Button criarBotao(String texto, int x, int y) {
Button botao = new Button();
botao.setText(texto);
this.include(botao,x,y);
return botao;
}
public void clickEvent(Component c) {
if (c == botaoCalcular) {
duplicarValor();
/* Funciona colocar
*
* campoEntrada.setText("");
*
* aqui, mas não faz sentido porque a abstração
* foi criada justamente para esconder estes detalhes.
*/
} else {
if (c == botaoSaida) {
sairDoSistema();
}
}
}
private void sairDoSistema() {
MiniJavaSystem system;
system = new MiniJavaSystem();
system.close();
}
private void duplicarValor() {
/* A primeira solução para tentar
* abrir uma janela de erro quando
* o usuário não digitar um número
* seria
*
* String s;
* if (campoEntrada == s) {
* abriria a janela de erro...
* }
*
* Mas isso não funciona pois s não é
* inicializada... e não podemos comparar
* um objeto de TextField (campoEntrada)
* com um de String (s). Mesmo
*
* (campoEntrada.getText() == s)
*
* não faria sentido pois s não foi
* inicializado; não sabe-se o significado
* por trás dele. Um teste parecido com
* este teria que ser feito após a leitura
* da informação digitada pelo usuário.
*
* Uma outra opção seria colocar
*
* if (campoEntrada != entrada) {
* abriria a janela de erro...
* }
*
* no final do método. Mas, de novo, temos
* problema de incompatibilidade de tipos.
* Mesmo resolvendo isso com
*
* if (campoEntrada.getInt() != entrada) {
* abriria a janela de erro...
* }
*
* a solução não faria sentido. Como a
* última linha antes do if seria
*
* campoEntrada.setText("");
*
* o valor de campoEntrada.getInt() seria 0.
* Assim, a janela de erro seria aberta mesmo
* quando o usuário não errar; ela seria aberta
* toda vez que o usuário digitasse um número
* diferente de 0. Já a condição
*
* if (campoEntrada.getInt() == entrada) {
* abriria a janela de erro...
* }
*
* faria com que a janela fosse aberta tanto
* quanto o usuário errasse (digitasse 1e2, por
* exemplo) quanto quando ele digitasse 0,
* que é um número válido.
*
* A solução passa por não usar o
* método getInt, que mascara o erro do
* usuário retornando 0, e usar o getIntExc.
*
* */
/*
* Usando o getIntExc, o tratamento da
* exceção corresponderá a mostrar a janela
* de erro. Mas como entrada não é inicializada
* quando o usuário não digita um número,
* o código abaixo não compila.
*
* int entrada;
* try {
* entrada = campoEntrada.getIntExc();
* } catch (InvalidConversionException e) {
* //e.printStackTrace();
* //entrada = 0;
* }
* resultado = 2 * entrada;
*
* Temos que colocar o código que acessa
* entrada dentro do try.
*/
/*
*
* Funciona, mas nada amigável...
* try {
entrada = campoEntrada.getIntExc();
int resultado;
resultado = 2 * entrada;
campoResultado.setInt(resultado);
} catch (InvalidConversionException e) {
e.printStackTrace();
}
*/
int entrada;
int resultado;
/*
* O código abaixo funciona, mas não
* trata outros tipos de exceções que
* podem ocorrer devido a erros do
* programador.
*
* try {
entrada = campoEntrada.getIntExc();
resultado = 2 * entrada;
campoResultado.setInt(resultado);
} catch (InvalidConversionException e) {
Window w;
w = new Window("Por favor, digite um número!");
w.setSize(500,100);
w.exitOnClose(false);
w.setVisible(true);
}
*/
/*
* Este código trata os outros tipos
* de erros, mas duplica código...
*
try {
entrada = campoEntrada.getIntExc();
resultado = 2 * entrada;
campoResultado.setInt(resultado);
} catch (InvalidConversionException e) {
Window w;
w = new Window("Por favor, digite um número!");
w.setSize(500,100);
w.exitOnClose(false);
w.setVisible(true);
} catch (Exception e) {
Window w;
w = new Window("Erro de programação, entre em contato com o suporte!");
w.setSize(900,100);
w.exitOnClose(false);
w.setVisible(true);
}*/
/* Finalmente, resolvendo o problema da
* duplicação de código...
*/
try {
entrada = campoEntrada.getIntExc();
resultado = 2 * entrada;
campoResultado.setInt(resultado);
} catch (InvalidConversionException e) {
campoResultado.setText("");
criarJanelaErro("Por favor, digite um número!", 500, 100);
} catch (Exception e) {
campoResultado.setText("");
criarJanelaErro("Erro de programação, entre em contato com o suporte!",900,100);
}
/*
* Muitas vezes é mais interessante colocar
* o catch de Exception no main ou em métodos
* como clickEvent, para programas que criam
* janelas.
*/
/* Uma alternativa ao código acima
* seria ter um único catch para
* capturar todas as exceções...
* Isso não é legal pois gera vários
* if-else aninhados, e é arriscado
* pois podemos esquecer alguma condição
* de if e o compilador não nos avisará.
try {
entrada = campoEntrada.getIntExc();
resultado = 2 * entrada;
campoResultado.setInt(resultado);
} catch (Exception e) {
if (e instanceof InvalidConversionException) {
criarJanelaErro("Por favor, digite um número!", 500, 100);
} else {
criarJanelaErro("Erro de programação, entre em contato com o suporte!",900,100);
}
}*/
campoEntrada.setText("");
}
private void criarJanelaErro(String tituloDaJanela, int x, int y) {
Window w;
w = new Window(tituloDaJanela);
w.setSize(x,y);
w.exitOnClose(false);
w.setVisible(true);
}
/* Além do método acima, caso seja necessário
* criar várias janelas de erro com um tamanho
* padrão, por exemplo 100-100, é interessante
* criar o método abaixo.
*/
private void criarJanelaErroComTamanhoPadrao(String tituloDaJanela) {
/*
* Implementar este método com o código
*
* Window w;
* w = new Window(tituloDaJanela);
* w.setSize(100,100);
* w.exitOnClose(false);
* w.setVisible(true);
*
* seria ruim pois duplicaria o código,
* o problema que a gente justamente
* estava tentando resolver quando definiu
* o método criarJanelaErro.
*
* */
criarJanelaErro(tituloDaJanela,100,100);
}
}