JPanel die eine der Hörer für die Sichtbarkeit richtige ist,

Question

geändert Gibt es einige Regeln, oder gute/schlechte Erfahrungen mit AncestorListener, ComponentListener oder HierarchyListener für die Sichtbarkeit von Änderungen mit JPanel hören und JComponents?

Ist einer von ihnen besser oder sicherer als die anderen? Ich möchte besonders gerne wissen, wann und wie JPanel/JComponent versteckt ist.

Beachten Sie den folgenden Code enthält falsche Swing-Regeln, wie Thread.sleep(int) verwenden, in diesem Fall, mir zu erlauben, richtige Reihenfolge der Listeners in Swing GUI

import java.awt.BorderLayout; 
import java.awt.CardLayout; 
import java.awt.event.ComponentEvent; 
import java.awt.event.ComponentListener; 
import java.awt.event.HierarchyEvent; 
import java.awt.event.HierarchyListener; 
import javax.swing.JButton; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.event.AncestorEvent; 
import javax.swing.event.AncestorListener; 

public class CardlayoutTest extends JFrame { 

    private static final long serialVersionUID = 1L; 
    public CardLayout card = new CardLayout(); 

    public CardlayoutTest() { 
     JPanel pnlA = new JPanel(new BorderLayout()); 
     pnlA.add(new JButton("A"), BorderLayout.CENTER); 
     JPanel pnlB = new JPanel(new BorderLayout()); 
     pnlB.add(new JButton("B"), BorderLayout.CENTER); 
     JPanel pnlC = new JPanel(new BorderLayout()); 
     pnlC.add(new JButton("C"), BorderLayout.CENTER); 

     setDefaultCloseOperation(EXIT_ON_CLOSE); 
     setLayout(card); 
     add(pnlA, "A"); 
     add(pnlB, "B"); 
     add(pnlC, "C"); 

     pnlA.addAncestorListener(new EventHandler()); 
     pnlB.addAncestorListener(new EventHandler()); 
     pnlC.addAncestorListener(new EventHandler()); 

     pnlA.addHierarchyListener(new EventHandler()); 
     pnlB.addHierarchyListener(new EventHandler()); 
     pnlB.addHierarchyListener(new EventHandler()); 

     pnlA.addComponentListener(new EventHandler()); 
     pnlB.addComponentListener(new EventHandler()); 
     pnlB.addComponentListener(new EventHandler()); 
    } 

    class EventHandler implements AncestorListener, ComponentListener, HierarchyListener { 

     @Override 
     public void ancestorAdded(AncestorEvent event) { 
      System.out.println("CardlayoutTest.EventHandler.ancestorAdded()"); 
     } 

     @Override 
     public void ancestorMoved(AncestorEvent event) { 
      System.out.println("CardlayoutTest.EventHandler.ancestorMoved()"); 
     } 

     @Override 
     public void ancestorRemoved(AncestorEvent event) { 
      System.out.println("CardlayoutTest.EventHandler.ancestorRemoved()"); 
     } 

     @Override 
     public void hierarchyChanged(HierarchyEvent e) { 
      System.out.println("Components Change: " + e.getChanged()); 
      if ((e.getChangeFlags() & HierarchyEvent.DISPLAYABILITY_CHANGED) != 0) { 
       if (e.getComponent().isDisplayable()) { 
        System.out.println("Components DISPLAYABILITY_CHANGED : " + e.getChanged()); 
       } else { 
        System.out.println("Components DISPLAYABILITY_CHANGED : " + e.getChanged()); 
       } 
      } 
      if ((e.getChangeFlags() & HierarchyEvent.SHOWING_CHANGED) != 0) { 
       if (e.getComponent().isDisplayable()) { 
        System.out.println("Components SHOWING_CHANGED : " + e.getChanged()); 
       } else { 
        System.out.println("Components SHOWING_CHANGED : " + e.getChanged()); 
       } 
      } 
     } 

     public void componentHidden(ComponentEvent e) { 
      System.out.println(e.getComponent().getClass().getName() + " --- Hidden"); 
     } 

     public void componentMoved(ComponentEvent e) { 
      System.out.println(e.getComponent().getClass().getName() + " --- Moved"); 
     } 

     public void componentResized(ComponentEvent e) { 
      System.out.println(e.getComponent().getClass().getName() + " --- Resized "); 
     } 

     public void componentShown(ComponentEvent e) { 
      System.out.println(e.getComponent().getClass().getName() + " --- Shown"); 
     } 
    } 

    public static void main(String[] args) { 
     CardlayoutTest t = new CardlayoutTest(); 
     t.setSize(500, 500); 
     System.out.println("CardlayoutTest.main()------------------------ FIRST"); 
     t.card.show(t.getContentPane(), "A"); 
     t.setVisible(true); 
     System.out.print("\n"); 
     try { 
      Thread.sleep(2000); 
     } catch (InterruptedException e) { 
     } 
     System.out.println("CardlayoutTest.main()------------------------ SECOND"); 
     t.card.show(t.getContentPane(), "B"); 
     System.out.print("\n"); 
     try { 
      Thread.sleep(2000); 
     } catch (InterruptedException e) { 
     } 
     System.out.println("CardlayoutTest.main()------------------------ THIRD"); 
     t.card.show(t.getContentPane(), "C"); 
     System.out.print("\n"); 
    } 
} 

Answer 1

auszudrucken-out, wenn Sie genau die Sichtbarkeit hören möchten

JPanel panel = new JPanel(); 
    panel.addComponentListener (new ComponentAdapter() 
    { 
     public void componentShown (ComponentEvent e) 
     { 
      System.out.println ("Component shown"); 
     } 

     public void componentHidden (ComponentEvent e) 
     { 
      System.out.println ("Component hidden"); 
     } 
    }); 

Aber dass die Sicht vielleicht nicht die, die Sie denken: - Änderungen ComponentListener oder ComponentAdapter verwenden. isVisible() flag wird true sein, auch wenn die Component zu keiner Container hinzugefügt wird und daher überhaupt nicht angezeigt wird!

Diese Sichtbarkeit hat einen etwas anderen Zweck. Sie können es verwenden, um die Component manuell auszublenden, die bereits hinzugefügt und irgendwo in Ihrer Anwendung angezeigt wird. In diesem Fall (wenn Sie setVisible(false) verwenden) wird es ausgeblendet und jeder ComponentListener dieser Component wird über diese Änderung informiert.

Also, im Gespräch über aktuelle Sicht ...

Dies ist, was sollten Sie tatsächliches Komponente Aussehen/Verschwinden zu hören verwenden:

JPanel panel = new JPanel(); 
    panel.addAncestorListener (new AncestorListener() 
    { 
     public void ancestorAdded (AncestorEvent event) 
     { 
      // Component added somewhere 
     } 

     public void ancestorRemoved (AncestorEvent event) 
     { 
      // Component removed from container 
     } 

     public void ancestorMoved (AncestorEvent event) 
     { 
      // Component container moved 
     } 
    }); 

ich immer, dass die Hörer verwenden, um festzustellen, wann die Component wird irgendwo hinzugefügt und auch zu hören, wenn es bewegt/entfernt wird.

Außerdem können Sie jederzeit überprüfen, ob die Component durch den Aufruf isShowing() Methode tatsächlich sichtbar Anwendung Benutzer:

boolean userCanSeeThePanel = panel.isShowing(); 

Dies wird true nur zurück, wenn das Panel sichtbar Anwenderrahmen hinzugefügt wird und isVisible() Flag auch wahr (es ist normalerweise true, es sei denn, Sie setzen es auf false).

Ich denke, das ist alles, was ich Ihnen über Sichtbarkeit sagen kann. Ich könnte deine Frage missverstanden haben. Korrigiere mich, wenn ich in diesem Fall falsch liege.