package abbot.finder;

 import java.awt.*;

 import java.awt.event.*;

 import java.util.*;

 import javax.swing.SwingUtilities;

 import javax.swing.JPopupMenu;

 import abbot.Log;

 import abbot.util.*;

 /** Provide isolation of a Component hierarchy to limit consideration to only

     those Components created during the lifetime of this Hierarchy instance.

     Extant Components (and any subsequently generated subwindows) are ignored

     by default.<p>

     Implicitly auto-filters windows which are disposed (i.e. generate a

     WINDOW_CLOSED event), but also implicitly un-filters them if they should

     be shown again.  Any Window explicitly disposed with

     {@link #dispose(Window)} will be ignored permanently.<p> 

 */

     // Map of components to ignore

     private Map filtered = new WeakHashMap();

     // Map of components implicitly filtered; these will be implicitly

     // un-filtered if they are re-shown.

     private Map transientFiltered = new WeakHashMap();

     private static boolean trackAppletConsole =

         Boolean.getBoolean("abbot.applet.track_console");

     /** Avoid GC of the weak reference. */

     private AWTEventListener listener;

     /** Create a new TestHierarchy which does not contain any UI

      * Components which might already exist.

      */ 

     }

     /** Create a new TestHierarchy, indicating whether extant Components

      * should be omitted from the Hierarchy.  

      */

         // Watch for introduction of transient dialogs so we can automatically

         // filter them on dispose (WINDOW_CLOSED).  Don't do anything when the

         // component is simply hidden, since we can't tell whether it will be

         // re-used. 

     }

     }

     /** Dispose of the given Window, but only if it currently exists within

      * the hierarchy.  It will no longer appear in this Hierarchy or be

      * reachable in a hierarchy walk. 

      */

         }

     }

     /** Make all currently extant components invisible to this Hierarchy,

      * without affecting their current state.

      */

         }

     }

     /** Returns all available root Windows, excluding those which have been

      * filtered.

      */

     }

     /** Returns all sub-components of the given Component, omitting those

      * which are currently filtered.

      */

             // NOTE: this only removes those components which are directly

             // filtered, not necessarily those which have a filtered ancestor.

         }

     }

     }

     /** Returns true if the given component will not be considered when

      * walking the hierarchy.  A Component is filtered if it has explicitly

      * been filtered via {@link #setFiltered(Component,boolean)}, or if

      * any <code>Window</code> ancestor has been filtered.

      */

             || ((c instanceof Window) && isFiltered(c.getParent()))

             || (!(c instanceof Window) && isWindowFiltered(c));

     }

     /** Indicates whether the given component is to be included in the

         Hierarchy.  If the component is a Window, recursively applies the

         action to all owned Windows. 

     */

             }

         }

         else {

             }

             else {

             }

                 }

             }

         }

     }

     /** Provides for automatic filtering of auto-generated Swing dialogs. */

             private Window w;

             }

             }

         }

             // Add a weak listener so we don't leave a listener lingering

             // about. 

                 | ComponentEvent.COMPONENT_EVENT_MASK;

         }

                 || (e.getID() == ComponentEvent.COMPONENT_SHOWN

                     && e.getSource() instanceof Window)) {

                 }

                 // Catch new sub-windows of filtered windows (i.e. dialogs

                 // generated by a test harness UI).

                 }

             }

                 // *Any* window disposal should result in the window being

                 // ignored, at least until it is again displayed.

                     // Filter only *after* any handlers for this event have

                     // finished.  

                 }

             }

         }

     }

 }