JLayeredPane - Guia completo do JLayeredPane com exemplos

Introdução ao JLayeredPane

JLayeredPane é um componente Swing que nos permite adicionar componentes a uma camada diferente. Um exemplo comum de uma "camada diferente" é um JLayeredPane pop-up. Quando precisamos mostrar algum diálogo, aviso ou informação, usamos uma janela pop-up. Isso pode ser alcançado usando o JLayeredPane.

Declaração:

public class JLayeredPane extends JComponent implements Accessible

Camadas de JLayeredPane

Aqui estão algumas camadas do JLayeredPane, conforme explicado abaixo em detalhes:

DEFAULT_LAYER: Essa é a camada padrão e mais abaixo, onde a maioria dos componentes é inserida.
PALETTE_LAYER: essa camada de JLayeredPanesits sobre a camada padrão e útil para barras de ferramentas e paletas flutuantes.
MODAL_LAYER: Essa camada do JLayeredPane é usada para diálogos de modelo e mostrada acima da camada da paleta.
POPUP_LAYER: Essa camada do JLayeredPane é usada para mostrar janelas pop-up acima da camada modal.
DRAG_LAYER: Um componente é mostrado nesta camada (acima da camada pop-up) enquanto o arrasta. Quando a arrastar termina, o componente é mostrado em sua camada original.

Detalhes do construtor: Este é o único construtor que cria um JLayeredPane.

public JLayeredPane()

Detalhes do método JLayeredPane

Aqui estão alguns métodos que usamos, explicados abaixo no JLayeredPane:

1. addImpl de void protegido (Comp componente, restrições de objeto, índice int): Este método adiciona um componente a esse container no índice especificado. Além disso, o LayoutManager é notificado para adicionar o componente especificado ao layout deste contêiner usando o objeto de restrições especificado. Para este método addLayoutComponent é usado.

2. remoção pública nula (índice int): esse método remove um componente do índice especificado nesse painel.

3. public void removeAll (): remove todos os componentes deste painel.

4. public boolean isOptimizedDrawingEnabled (): se as camadas no painel puderem se sobrepor, torna impossível o desenho otimizado e retorna falso. Caso contrário, é verdade.

5. public static void putLayer (JComponent c, int layer): esse método define a camada para um JComponent. Este método não causa efeitos colaterais como pintar, adicionar, remover etc. Para ter esses efeitos colaterais, você pode usar o método setLayer ().

6. public static int getLayer (JComponent c): Este método retorna o atributo de camada do JComponent especificado.

7. public static JLayeredPane getLayeredPaneAbove (Component c): Este método retorna o primeiro JLayeredPane que contém o componente especificado ou retorna null se nenhum JLayeredPane for encontrado.

8. public void setLayer (Componente c, camada int): Este método define o atributo JLayeredPane do componente especificado. Torna o componente mais abaixo na camada especificada.

9. public void setLayer (Componente c, camada int, posição int): Este método define o atributo da camada do componente especificado e define a posição do componente nessa camada.

10. public int getLayer (Componente c): Este método retorna o atributo de camada do Componente especificado.

11. public int getIndexOf (Componente c): Este método retorna o índice do componente especificado no painel, ignorando as camadas. O componente mais alto está no índice zero e o componente mais baixo está no índice mais alto.

12. public void moveToFront (Componente c): Este método move o componente especificado para o topo em sua camada atual (posição 0).

13. public void moveToBack (Componente c): Este método move o componente especificado para o fundo em sua camada atual (posição -1).

14. public void setPosition (Componente c, posição int): Este método define a posição do componente especificado em sua camada, onde 0 é a posição mais alta e –1 é a posição mais baixa.

15. public int getPosition (Componente c): Este método retorna a posição relativa do componente dentro de sua camada.

16. public int maximumLayer (): Este método retorna o valor da camada mais alta de todos os filhos atuais. Se não houver filhos, ele retornará 0.

17. public int lowerLayer (): Este método retorna o valor da camada mais baixa de todos os filhos atuais. Se não houver filhos, ele retornará 0.

18. public int getComponentCountInLayer (int layer): esse método retorna o número de filhos atualmente presentes na camada especificada.

19. public Component () getComponentsInLayer (camada int): Este método retorna os componentes em uma matriz presente na camada especificada.

20. Public Void Paint (Gráficos g): Este método pinta este JLayeredPane dentro do contexto gráfico especificado.

21. Hashtable protegido getComponentToLayer (): Este método retorna um HashTable que mapeia componentes em camadas.

22. Integer protegido getObjectForLayer (int layer): Este método retorna o número inteiro associado à camada especificada.

23. protected int insertIndexForLayer (camada int, posição int): Este método determina e retorna o local apropriado para inserir um novo filho com base na camada e posição especificadas.

24. String protegida paramString (): Este método retorna a representação de string deste painel. Este método é usado internamente para fins de depuração.

25. public AccessibleContext getAccessibleContext (): este método retorna o AccessibleContext associado a este painel.

Exemplo de JLayeredPane

Aqui está um exemplo de JLayeredPane fornecido abaixo com uma explicação:

Código:

import java.awt.Color; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLayeredPane; public class JLayeredPaneDemo ( public static void main(String() args) ( JFrame frame = new JFrame("JLayeredPane Demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(520, 530); JLayeredPane jLayeredPane = new JLayeredPane(); JButton jButton1 = new JButton("Open"); jButton1.setBackground(Color.green); jButton1.setBounds(175, 50, 150, 100); jLayeredPane.add(jButton1, JLayeredPane.DEFAULT_LAYER); JButton jButton2 = new JButton("Open"); JButton jButton3 = new JButton("Close"); jButton2.setVisible(false); jButton3.setVisible(false); jButton2.setBackground(Color.RED); jButton3.setBackground(Color.RED); jButton2.setBounds(75, 125, 150, 100); jButton3.setBounds(275, 125, 150, 100); jLayeredPane.add(jButton2, JLayeredPane.PALETTE_LAYER); jLayeredPane.add(jButton3, JLayeredPane.PALETTE_LAYER); JButton jButton4 = new JButton("Open"); JButton jButton5 = new JButton("Close"); jButton4.setVisible(false); jButton5.setVisible(false); jButton4.setBackground(Color.MAGENTA); jButton5.setBackground(Color.MAGENTA); jButton4.setBounds(95, 200, 150, 100); jButton5.setBounds(255, 200, 150, 100); jLayeredPane.add(jButton4, JLayeredPane.MODAL_LAYER); jLayeredPane.add(jButton5, JLayeredPane.MODAL_LAYER); JButton jButton6 = new JButton("Open"); JButton jButton7 = new JButton("Close"); jButton6.setVisible(false); jButton7.setVisible(false); jButton6.setBackground(Color.CYAN); jButton7.setBackground(Color.CYAN); jButton6.setBounds(75, 275, 150, 100); jButton7.setBounds(275, 275, 150, 100); jLayeredPane.add(jButton6, JLayeredPane.POPUP_LAYER); jLayeredPane.add(jButton7, JLayeredPane.POPUP_LAYER); JButton jButton8 = new JButton("Close"); jButton8.setVisible(false); jButton8.setBackground(Color.GRAY); jButton8.setBounds(175, 350, 150, 100); jLayeredPane.add(jButton8, JLayeredPane.DRAG_LAYER); frame.add(jLayeredPane); frame.setVisible(true); jButton1.addActionListener(e -> ( jButton2.setVisible(true); jButton3.setVisible(true); )); jButton2.addActionListener(e -> ( jButton4.setVisible(true); jButton5.setVisible(true); )); jButton3.addActionListener(e -> ( jButton2.setVisible(false); jButton3.setVisible(false); )); jButton4.addActionListener(e -> ( jButton6.setVisible(true); jButton7.setVisible(true); )); jButton5.addActionListener(e -> ( jButton4.setVisible(false); jButton5.setVisible(false); )); jButton6.addActionListener(e -> ( jButton8.setVisible(true); )); jButton7.addActionListener(e -> ( jButton6.setVisible(false); jButton7.setVisible(false); )); jButton8.addActionListener(e -> ( jButton8.setVisible(false); )); ) )

Explicação

Neste exemplo, implementamos um programa que mostra diferentes camadas do JLayeredPane e como inserir / remover componentes do painel.

Primeiro, criamos um quadro e adicionamos um JLayeredPane a ele.
Em seguida, foram adicionados botões em diferentes camadas do JLayeredPane.
Ouvintes de ação anexados aos botões para mostrar ou ocultar a próxima camada.
A posição dos botões com a camada é definida para que pareça adequada.

Resultado:

1. Esta é a nossa aplicação e este botão verde é adicionado à camada mais inferior.

2. Quando um usuário clica em um botão verde da primeira camada, a segunda camada é aberta.

3. Ao clicar no botão Abrir na segunda camada, a terceira camada no JLayeredPane é aberta.

4. Ao clicar no botão Abrir na terceira camada, a quarta camada é aberta.

5. Ao clicar no botão Abrir na quarta camada, a quinta camada é aberta.

6. Ao clicar no botão Fechar na quinta camada, a camada do JLayeredPane é fechada.

7. Quando você clica no botão Fechar na quarta camada, a camada do JLayeredPane é fechada.

8. Ao clicar no botão Fechar na terceira camada, a camada do JLayeredPane é fechada.

9. Quando você clica no botão Fechar na segunda camada, a camada é fechada.

Conclusão

O JLayeredPane é fácil de usar e um componente importante no Swing. Isso facilita a decisão entre os componentes enquanto se sobrepõem situações.

Artigos recomendados

Este é um guia para o JLayeredPane. Aqui discutimos as camadas, o construtor e os métodos do JLayeredPane, juntamente com o exemplo e sua implementação de código. Você também pode consultar os seguintes artigos para saber mais -