É o seguinte, criei um evento(keypressed) no meu jpainel, o problema é que ele não execulta esse meu evento.
O evento é para quando uma pessoa apertar a tecla F12 aparecer o botão de cadastro que eu coloquei invisivel.
o meu código é assim
import java.awt.event.*;
import javax.swing.*;
public class GUIPrincipal extends javax.swing.JFrame {
JFrame GuiPrincipal;
public GUIPrincipal() {
initComponents();
key();
}
..... //continuação do código
private void Painel1KeyPressed(java.awt.event.KeyEvent evt) {
if (evt.getKeyCode() == KeyEvent.VK_F12){
bCadastrarFuncionario.setVisible(true);
lCadastroFuncionario.setVisible(false);
}
if (evt.getKeyCode() == KeyEvent.VK_ESCAPE){
bCadastrarFuncionario.setVisible(false);
lCadastroFuncionario.setVisible(true);
}
}
private void key() {
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
Painel1KeyPressed(e);
}
});
pack();
}
sou iniciante no java e não sei como fazer isso funcionar. Se alguém puder me ajudar eu agradeço.
Olá,
Utilize o exemplo do Vinícius como base para implementar o que você precisa: http://www.guj.com.br/posts/list/140986.java
[]´s
davidbuzatto, você poderia me dar uma exemplo de como ficaria isso implementado no meu código, pois não entendi algumas partes do código (do Vinícius), sou novato no java, comecei a mexer com java a menos de um mês. Estou estudando só através de livro e sites como esse.
Tente fazer assim:
Coloque este codigo no construtor da sua janela…
getRootPane().getInputMap(JPanel.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke(KeyEvent.VK_F12, 0, true),"FUNCAO_F12");
getRootPane().getActionMap().put("FUNCAO_F12", new AbstractAction() {
public void actionPerformed(ActionEvent e) {
bCadastrarFuncionario.setVisible(true);
lCadastroFuncionario.setVisible(false);
}
});
abraço
[quote=david.jv]davidbuzatto, você poderia me dar uma exemplo de como ficaria isso implementado no meu código, pois não entendi algumas partes do código (do Vinícius), sou novato no java, comecei a mexer com java a menos de um mês. Estou estudando só através de livro e sites como esse.
[/quote]
Oi David,
Assim que eu chegar em casa mais tarde eu faço um exemplo para vc e comento o código p/ te ajudar a entender 
[]´s
Oi, desculpa a demora. Recomendo primeiramente que você leia a teoria do funcionamento que o Vinícius apresentou no link que eu passei.
Agora, segue o código comentado
[code]import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
/**
*
-
@author David Buzatto
*/
public class MeuFrame extends JFrame {
// um painel -é no ActionMap dele que vão ser registradas as ações e é no
// InputMap dele que as ações vão ser mapeadas para as teclas
private JPanel painel;
// dois botões para mostrar o funcionamento
private JButton btn1;
private JButton btn2;
public MeuFrame() {
// configura o JFrame
setSize( 300, 300 );
setTitle( "Teste" );
setVisible( true );
setDefaultCloseOperation( EXIT_ON_CLOSE );
// instancia os componentes
painel = new JPanel();
btn1 = new JButton( "botão 1" );
btn2 = new JButton( "botão 2" );
// seta o layout do JFrame como FlowLayout
setLayout( new FlowLayout() );
// adiciona os três componenets no JFrame
add( painel );
add( btn1 );
add( btn2 );
// aqui a mágica acontece... veja o método abaixo
registrarAcoesTeclado();
}
// este método vai inserir as ações (actions) no mapa de ações do painel
// e vai mapear cada uma dessas ações a uma tecla específica
private void registrarAcoesTeclado() {
// obtém o mapa de ações do painel
ActionMap actionMap = painel.getActionMap();
/*
* actionMap.put( chave, ação ) insere uma ação no mapa, usando uma
* chave para identificar a ação.
*
* Neste primeiro caso, a chave é F12. Imagine essa chave como um tipo
* de nome de variável.
*
* Um mapa é parecido com um array, mas no mapa, você dá nomes para as
* posições onde estão os valores. Em um array, vc tem um índice que
* inicia em 0 e segue até o tamanho do array menos 1.
*
* Em um mapa, as posições tem nomes. Por exemplo, posição "x", posição
* "y", sendo que esses nomes são objetos. Neste caso, os nomes que
* estamos criando são Strings.
*
* "F12" então é o nome da posição onde estamos guardando uma ação.
* Poderia ser qualquer outro nome que você quisesse.
*
* A ação, por sua vez, está sendo criada como uma classe interna anônima.
* Você já deve ter usado classes internas anônimas para registrar
* eventos não é?
*
* Enfim, o new AbstractAction() {...} cria uma nova classe (sem nome)
* que estende AbstractAction e já instancia o objeto dessa classe
* criada. Note que dentro da ação, precisamos implementar o método
* actionPerformed, que vai ser executado quando esta ação for invocada.
*
* Olhe o corpo do metodo, nele setamos btn1 como invisível e btn2 como
* visivel.
*/
actionMap.put( "F12", new AbstractAction() {
public void actionPerformed( ActionEvent e ) {
btn1.setVisible( false );
btn2.setVisible( true );
}
});
/*
* Aqui fazemos a mesma coisa que na instrução anterior, ou seja, inserimos
* um item (ação) no mapa, identificado como "ESC", sendo que a ação
* inserida tbm é um objeto de uma classe interna anônima e o método
* actionPerformed faz btn1 ficar visível, enquanto btn2 invisível
*/
actionMap.put( "ESC", new AbstractAction() {
public void actionPerformed( ActionEvent e ) {
btn1.setVisible( true );
btn2.setVisible( false );
}
});
/*
* Até aqui apenas registramos as ações, ainda não amarramos elas ao
* pressionamento de teclas. Vamos fazer isso agora.
*/
/*
* Primeiro obtemos o InputMap do "tipo" WHEN_IN_FOCUSES_WINDOW, ou seja
* o InputMap é "executado" quando a janela que contém o componente em
* questão está em foco.
*/
InputMap inputMap = painel.getInputMap( JPanel.WHEN_IN_FOCUSED_WINDOW );
/*
* Agora amarramos cada item do mapa que ações (actionMap) com teclas
* específicas no inputMap que foi obtido na linha anterior.
*/
/*
* Obtém o keystroke da tecla F12 (VK_F12) e "amarra" ele a ação chamada
* de F12 no actionMap.
*
* Observe que é aqui que a tecla (representada pelo KeyStroke) é amarrada
* à ação desejada.
*
* Se o nome usado no actionMap fosse "MINHA_ACAO",
* neste momento, o segundo parâmetro do método put do inputMap deveria
* ser tbm "MINHA_ACAO" entendeu?
*/
inputMap.put( KeyStroke.getKeyStroke( "F12" ), "F12" );
/*
* Mesma coisa que a linha anterior. Obtem o KeyStroke da tecla ESC
* (VK_ESCAPE) e associa ele à ação chamada "ESC".
*/
inputMap.put( KeyStroke.getKeyStroke( "ESCAPE" ), "ESC" );
/*
* Pronto, a partir daqui, as ações criadas estão mapeadas às teclas
* desejadas. Quando uma tecla for pressionada e caso ela esteja regitrada
* no inputMap, a ação associada a tecla será disparada.
*/
}
/*
- Método main para instanciar o JFrame e executar a classe
*/
public static void main( String[] args ) {
new MeuFrame();
}
}[/code]
Se ainda tiver mais alguma dúvida é só perguntar
[]´s
davidbuzatto e looljunior, muito obrigado, os dois códigos funfaram perfeitamente. Vlw
tópico concluido.