JPanel जो श्रोताओं में से एक दृश्यता के लिए उचित है

Question

बदल गया है वहाँ कुछ नियम हैं, या AncestorListener, ComponentListener या HierarchyListener के साथ अच्छे/बुरे अनुभव JPanel और JComponents के साथ परिवर्तन की दृश्यता के लिए सुन रहे हैं?

उनमें से एक दूसरों के मुकाबले बेहतर या सुरक्षित है? मैं विशेष रूप से जानना चाहता हूं कि कब और कैसे JPanel/JComponent छिपा हुआ है।

सूचना निम्नलिखित कोड का उपयोग कर इस मामले में Thread.sleep(int), जैसे, गलत स्विंग नियम शामिल हैं, मुझे प्रिंट आउट करने के लिए Listeners का सही क्रम स्विंग जीयूआई

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

में आप वास्तव में दृश्यता सुनने के लिए चाहते हैं अनुमति देने के लिए परिवर्तन - का उपयोग ComponentListener या 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 में जोड़ा नहीं गया है और इसलिए बिल्कुल दिखाई नहीं दे रहा है!

उस दृश्यता का थोड़ा अलग उद्देश्य है। आप इसे Component मैन्युअल रूप से छुपाने के लिए उपयोग कर सकते हैं जो पहले से ही आपके एप्लिकेशन में कहीं भी जोड़ा गया है और दिखाया गया है। उस स्थिति में, (यदि आप setVisible(false) का उपयोग करते हैं) तो यह छिप जाएगा और उस Component के प्रत्येक ComponentListener को उस परिवर्तन के बारे में सूचित किया जाएगा।

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 कहीं भी जोड़ा जाता है और जब इसे स्थानांतरित/हटाया जाता है तो सुनना भी होता है।

boolean userCanSeeThePanel = panel.isShowing(); 

यह true वापस आ जाएगी केवल कि अगर पैनल उपयोगकर्ता फ्रेम को दिखाई में जोड़ा जाता है और isVisible() झंडा है:

इसके अलावा, आप हमेशा अगर ComponentisShowing() विधि को फोन करके वास्तव में उपयोगकर्ता आवेदन करने के लिए दिख रहा है जाँच कर सकते हैं यह भी सच है (यह आमतौर पर true है, जब तक कि आप इसे false पर सेट न करें)।

मुझे लगता है कि मैं आपको दृश्यता के बारे में बता सकता हूं। मैंने आपके प्रश्न को गलत समझा होगा। अगर मैं उस मामले में गलत हूं तो मुझे सही करें।