home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / AncestorNotifier.java < prev    next >
Text File  |  1998-02-26  |  7KB  |  229 lines
  1. /*
  2.  * @(#)AncestorNotifier.java    1.6 98/01/30
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23.  
  24. import com.sun.java.swing.event.*;
  25. import java.awt.event.*;
  26.  
  27. import java.awt.Component;
  28. import java.awt.Container;
  29. import java.awt.Window;
  30. import java.beans.PropertyChangeListener;
  31. import java.beans.PropertyChangeEvent;
  32.  
  33. import java.io.Serializable;
  34.  
  35.  
  36. /**
  37.  * @version 1.6 01/30/98
  38.  * @author Dave Moore
  39.  */
  40.  
  41. class AncestorNotifier implements ComponentListener, PropertyChangeListener, Serializable 
  42. {
  43.     Component firstInvisibleAncestor;
  44.     EventListenerList listenerList = new EventListenerList();
  45.     JComponent root;
  46.  
  47.     AncestorNotifier(JComponent root) {
  48.     this.root = root;
  49.            addListeners(root, true);
  50.     }
  51.  
  52.     void addAncestorListener(AncestorListener l) {
  53.     listenerList.add(AncestorListener.class, l);
  54.     }
  55.  
  56.     void removeAncestorListener(AncestorListener l) {
  57.     listenerList.remove(AncestorListener.class, l);
  58.     }
  59.  
  60.     /*
  61.      * Notify all listeners that have registered interest for
  62.      * notification on this event type.  The event instance 
  63.      * is lazily created using the parameters passed into 
  64.      * the fire method.
  65.      * @see EventListenerList
  66.      */
  67.     protected void fireAncestorAdded(JComponent source, int id, Container ancestor, Container ancestorParent) {
  68.     // Guaranteed to return a non-null array
  69.     Object[] listeners = listenerList.getListenerList();
  70.     // Process the listeners last to first, notifying
  71.     // those that are interested in this event
  72.     for (int i = listeners.length-2; i>=0; i-=2) {
  73.         if (listeners[i]==AncestorListener.class) {
  74.         // Lazily create the event:
  75.         AncestorEvent ancestorEvent = 
  76.             new AncestorEvent(source, id, ancestor, ancestorParent);
  77.         ((AncestorListener)listeners[i+1]).ancestorAdded(ancestorEvent);
  78.         }           
  79.     }
  80.     }    
  81.     
  82.     /*
  83.      * Notify all listeners that have registered interest for
  84.      * notification on this event type.  The event instance 
  85.      * is lazily created using the parameters passed into 
  86.      * the fire method.
  87.      * @see EventListenerList
  88.      */
  89.     protected void fireAncestorRemoved(JComponent source, int id, Container ancestor, Container ancestorParent) {
  90.     // Guaranteed to return a non-null array
  91.     Object[] listeners = listenerList.getListenerList();
  92.     // Process the listeners last to first, notifying
  93.     // those that are interested in this event
  94.     for (int i = listeners.length-2; i>=0; i-=2) {
  95.         if (listeners[i]==AncestorListener.class) {
  96.         // Lazily create the event:
  97.         AncestorEvent ancestorEvent = 
  98.             new AncestorEvent(source, id, ancestor, ancestorParent);
  99.         ((AncestorListener)listeners[i+1]).ancestorRemoved(ancestorEvent);
  100.         }           
  101.     }
  102.     }    
  103.     /*
  104.      * Notify all listeners that have registered interest for
  105.      * notification on this event type.  The event instance 
  106.      * is lazily created using the parameters passed into 
  107.      * the fire method.
  108.      * @see EventListenerList
  109.      */
  110.     protected void fireAncestorMoved(JComponent source, int id, Container ancestor, Container ancestorParent) {
  111.     // Guaranteed to return a non-null array
  112.     Object[] listeners = listenerList.getListenerList();
  113.     // Process the listeners last to first, notifying
  114.     // those that are interested in this event
  115.     for (int i = listeners.length-2; i>=0; i-=2) {
  116.         if (listeners[i]==AncestorListener.class) {
  117.         // Lazily create the event:
  118.         AncestorEvent ancestorEvent = 
  119.             new AncestorEvent(source, id, ancestor, ancestorParent);
  120.         ((AncestorListener)listeners[i+1]).ancestorMoved(ancestorEvent);
  121.         }           
  122.     }
  123.     }    
  124.  
  125.     void removeAllListeners() {
  126.     removeListeners(root);
  127.     }
  128.  
  129.     void addListeners(Component ancestor, boolean addToFirst) {
  130.     Component a;
  131.  
  132.     firstInvisibleAncestor = null;
  133.     for (a = ancestor;
  134.          firstInvisibleAncestor == null;
  135.          a = a.getParent()) {
  136.         if (addToFirst || a != ancestor) {
  137.         a.addComponentListener(this);
  138.  
  139.         if (a instanceof JComponent) {
  140.             JComponent jAncestor = (JComponent)a;
  141.  
  142.             jAncestor.addPropertyChangeListener(this);
  143.         }
  144.         }
  145.         if (!a.isVisible() || a.getParent() == null) {
  146.         firstInvisibleAncestor = a;
  147.         }
  148.     }
  149.     if (firstInvisibleAncestor instanceof Window) {
  150.         firstInvisibleAncestor = null;
  151.     }
  152.     }
  153.  
  154.     void removeListeners(Component ancestor) {
  155.     Component a;
  156.     for (a = ancestor;
  157.          a != firstInvisibleAncestor;
  158.          a = a.getParent()) {
  159.         a.removeComponentListener(this);
  160.         if (a instanceof JComponent) {
  161.         JComponent jAncestor = (JComponent)a;
  162.  
  163.         jAncestor.removePropertyChangeListener(this);
  164.         }
  165.     }
  166.     }
  167.  
  168.     public void componentResized(ComponentEvent e) {}
  169.  
  170.     public void componentMoved(ComponentEvent e) {
  171.     Component source = e.getComponent();
  172.  
  173.     fireAncestorMoved(root, AncestorEvent.ANCESTOR_MOVED,
  174.               (Container)source, source.getParent());
  175.     }
  176.  
  177.     public void componentShown(ComponentEvent e) {
  178.     Component ancestor = e.getComponent();
  179.  
  180.     if (ancestor == firstInvisibleAncestor) {
  181.         addListeners(ancestor, false);
  182.         if (firstInvisibleAncestor == null) {
  183.         fireAncestorAdded(root, AncestorEvent.ANCESTOR_ADDED,
  184.                   (Container)ancestor, ancestor.getParent());
  185.         }
  186.     }
  187.     }
  188.     
  189.     public void componentHidden(ComponentEvent e) {
  190.     Component ancestor = e.getComponent();
  191.     boolean needsNotify = firstInvisibleAncestor == null;
  192.  
  193.     removeListeners(ancestor.getParent());
  194.     firstInvisibleAncestor = ancestor;
  195.     if (needsNotify) {
  196.         fireAncestorRemoved(root, AncestorEvent.ANCESTOR_REMOVED,
  197.                 (Container)ancestor, ancestor.getParent());
  198.     }
  199.     }
  200.  
  201.     public void propertyChange(PropertyChangeEvent evt) {
  202.     String s = evt.getPropertyName();
  203.  
  204.     if (s.equals("parent") || s.equals("ancestor")) {
  205.         JComponent component = (JComponent)evt.getSource();
  206.  
  207.         if (evt.getNewValue() != null) {
  208.         if (component == firstInvisibleAncestor) {
  209.             addListeners(component, false);
  210.             if (firstInvisibleAncestor == null) {
  211.             fireAncestorAdded(root, AncestorEvent.ANCESTOR_ADDED,
  212.                       component, component.getParent());
  213.             }
  214.         }
  215.         } else {
  216.         boolean needsNotify = firstInvisibleAncestor == null;
  217.         Container oldParent = (Container)evt.getOldValue();
  218.  
  219.         removeListeners(oldParent);
  220.         firstInvisibleAncestor = component;
  221.         if (needsNotify) {
  222.             fireAncestorRemoved(root, AncestorEvent.ANCESTOR_REMOVED,
  223.                     component, oldParent);
  224.         }
  225.         }
  226.     }
  227.     }
  228. }
  229.