更改了其中一个监听器适合可见性的 JPanel [英] JPanel which one of Listeners is proper for visibility is changed
问题描述
AncestorListener、ComponentListener 或 HierarchyListener 使用 JPanel 监听更改的可见性是否有一些规则或好的/坏的体验 和 JComponents?
Are there some rules, or good/bad experiences with AncestorListener, ComponentListener or HierarchyListener listening for visibility of changes with JPanel and JComponents?
其中一个比其他的更好或更安全吗?我特别想知道JPanel/JComponent 何时以及如何隐藏.
Is one of them better or safer than the others? I would especially like to know about when and how JPanel / JComponent is hidden.
注意以下代码包含不正确的 Swing 规则，例如使用 Thread.sleep(int)，在这种情况下，允许我打印出 Listeners 的正确顺序在 Swing GUI 中
Notice the following code contains incorrect Swing rules, like using Thread.sleep(int), in this case, to allow me to print-out correct order of 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("
");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("CardlayoutTest.main()------------------------ SECOND");
t.card.show(t.getContentPane(), "B");
System.out.print("
");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("CardlayoutTest.main()------------------------ THIRD");
t.card.show(t.getContentPane(), "C");
System.out.print("
");
}
}
推荐答案
如果你想完全监听可见性变化 - 使用 ComponentListener 或 ComponentAdapter:
If you want to listen EXACTLY the visibility changes - use ComponentListener or ComponentAdapter:
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" );
}
} );
但是这种可见性可能不是您想象的那样.isVisible() 标志将为 true 即使 Component 未添加到任何 Container 并且因此不会显示在全部！
But that visibility might not be the one you think about. isVisible() flag will be true even if the Component is not added to any Container and hence not showing at all!
可见性 a 的目的略有不同.您可以使用它来手动隐藏已添加并显示在您的应用程序中的 Component.在这种情况下，(如果您使用 setVisible(false))它将变为隐藏状态，并且该 Component 的每个 ComponentListener 都会被告知该更改.
That visibility a has a slightly different purpose. You can use it to manually hide the Component that is already added and shown somewhere in your application. In that case, (if you use setVisible(false)) it will become hidden and every ComponentListener of that Component will be informed about that change.
所以，谈论实际可见性...
So, talking about actual visibility...
这是您应该用来监听实际组件外观/消失的内容:
This is what you should use to listen to actual component appearance/disappearance:
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
}
} );
我总是使用该侦听器来确定何时将 Component 添加到某处，并在它被移动/移除时进行侦听.
I always use that listener to determine when the Component is added somewhere and also to listen when it is moved/removed.
此外，您始终可以通过调用 isShowing() 方法来检查 Component 是否对应用程序用户实际可见:
Also, you can always check if the Component is actually visible to application user by calling isShowing() method:
boolean userCanSeeThePanel = panel.isShowing();
仅当该面板被添加到 VISIBLE 到用户框架并且 isVisible() 标志也为真(通常是 true)时，这才会返回 truecode>，除非您将其设置为 false).
This will return true ONLY if that panel is added to VISIBLE to user frame and isVisible() flag is also true (it is usually true, unless you set it to false).
我想这就是我能告诉你的关于可见性的全部内容.我可能误解了你的问题.如果我错了，请纠正我.
I guess that's all I can tell you about visibility. I might have misunderstood your question. Correct me if I am wrong in that case.
这篇关于更改了其中一个监听器适合可见性的 JPanel的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
