package abbot.tester;

 import java.awt.*;

 import java.awt.event.*;

 import javax.swing.JFrame;

 import javax.swing.SwingUtilities;

 import java.lang.ref.*;

 import java.util.*;

 import abbot.Log;

 import abbot.Platform;

 import abbot.util.Properties;

 import abbot.util.WeakAWTEventListener;

 import abbot.util.NamedTimer;

 /** Keep track of all known root windows, and all known showing/hidden/closed

  * windows.

  */

         public static final WindowTracker INSTANCE = new WindowTracker();

     }

     /** Maps unique event queues to the set of root windows found on each

         queue. 

      */

     private Map contexts;

     /** Maps components to their corresponding event queues. */

     private Map queues;

     private ContextTracker contextTracker;

     /** Windows which for which isShowing is true but are not yet ready for

         input. */

     private Map pendingWindows = new WeakHashMap();

     /** Windows which we deem are ready to use.  */

     private Map openWindows = new WeakHashMap();

     /** Windows which are not visible. */

     private Map hiddenWindows = new WeakHashMap();

     /** Windows which have sent a WINDOW_CLOSE event. */

     private Map closedWindows = new WeakHashMap();

     private WindowReadyTracker windowReadyTracker;

     private java.awt.Robot robot;

     static int WINDOW_READY_DELAY = 

         Properties.getProperty("abbot.window_ready_delay", 5000, 0, 60000);

     private Timer windowReadyTimer;

     /** Only ever want one of these. */

     }

     /** Create an instance of WindowTracker which will track all windows

      * coming and going on the current and subsequent app contexts. 

      * WARNING: if an applet loads this class, it will only ever see stuff in

      * its own app context.

      */

             | ComponentEvent.COMPONENT_EVENT_MASK;

             |InputEvent.MOUSE_EVENT_MASK|InputEvent.PAINT_EVENT_MASK;

         // hold the event queue references weakly

         // each queue maps to a set of components (actually a weak hash map to

         // allow GC of the component keys).

                      new WeakHashMap());

         // hold both the component references and the event queues weakly

         // Populate stuff that may already have shown/been hidden

             }

         }

         }

         catch(AWTException e) {

         }

     }

         // Make sure we catch subsequent show/hide events for this window

         }

         }

     }

     /** Returns whether the window is ready to receive OS-level event input.

         A window's "isShowing" flag may be set true before the WINDOW_OPENED

         event is generated, and even after the WINDOW_OPENED is sent the

         window peer is not guaranteed to be ready.

     */ 

                 && !hiddenWindows.containsKey(w)) {

             }

         }

     }

     /** Return the event queue corresponding to the given component.  In most

         cases, this is the same as

         Component.getToolkit().getSystemEventQueue(), but in the case of

         applets will bypass the AppContext and provide the real event queue.

     */

         // Components above the applet in the hierarchy may or may not share

         // the same context with the applet itself.

         }

     }

     /** Returns all known event queues. */

             }

         }

     }

     /** Return all available root Windows.  A root Window is one

      * that has a null parent.  Nominally this means a list similar to that

      * returned by Frame.getFrames(), but in the case of an Applet may return

      * a few Dialogs as well.

      */

         // Use Frame.getFrames() here in addition to our watched set, just in

         // case any of them is missing from our set.

             }

         }

         }

         //Log.debug(String.valueOf(list.size()) + " total Frames");

     }

     /** Provides tracking of window visibility state.  We explicitly add this

      * on WINDOW_OPEN and remove it on WINDOW_CLOSE to avoid having to process

      * extraneous ComponentEvents.

      */

         extends WindowAdapter implements ComponentListener {

         }

         }

                 //Log.log("Marking " + e.getSource() + " hidden");

             }

         }

         }

     }

     /** Whenever we get a window that's on a new event dispatch thread, take

      * note of the thread, since it may correspond to a new event queue and

      * AppContext. 

      */

     // FIXME what if it has the same app context? can we check?

             // This is our sole means of accessing other app contexts

             // (if running within an applet).  We look for window events

             // beyond OPENED in order to catch windows that have already

             // opened by the time we start listening but which are not

             // in the Frame.getFrames list (i.e. they are on a different

             // context).   Specifically watch for COMPONENT_SHOWN on applets,

             // since we may not get frame events for them.

                 && !(comp instanceof Window)) {

             }

             }

             }

                 // ignore

             }

             // Take note of all other window events

                       && id <= WindowEvent.WINDOW_LAST)

                      || id == ComponentEvent.COMPONENT_SHOWN) {

                         || closedWindows.containsKey(comp)) {

                     }

                 }

             }

             // The context for root-level windows may change between

             // WINDOW_OPENED and subsequent events.

                     && !comp.getToolkit().getSystemEventQueue().

                     equals(ref.get())) {

                 }

             }

         }

     }

                 || e.getID() == MouseEvent.MOUSE_DRAGGED) {

                     ? (Window)c

                     : SwingUtilities.getWindowAncestor(c);

             }

         }

     }

             }

             }

         }

     }

         //Log.log("Noting " + comp + " opened");

         // Attempt to ensure the window is ready for input before recognizing

         // it as "open".  There is no Java API for this, so we institute an

         // empirically tested delay.

         }

     }

                 else {

                         }

                     }

                                 + Robot.toString(comp)

                                 + " on a previously unseen context: "

                                 + queue + "("

                                 + Thread.currentThread() + ")");

                     }

                     else {

                                 + " sent WINDOW_CLOSED on "

                                 + queue + " but sent WINDOW_OPENED on "

                                 + foundQueue);

                     }

                 }

             }

         }

             //Log.log("Marking " + comp + " closed");

         }

     }

     /** Mark the given Window as ready for input.  Indicate whether any

      * pending "mark ready" task should be canceled.

      */

             // If the window was closed after the check timer started running,

             // it will have canceled the pending ready.

             // Make sure it's still on the pending list before we actually

             // mark it ready.

                 //Log.log("Noting " + w + " ready");

             }

         }

     }

     /** Indicate a window has set isShowing true and needs to be marked ready

         when it is actually ready.

     */

         }

     }

         }

         catch(NullPointerException e) {

             // FileDialog.getInsets() throws (1.4.2_07)

         }

     }

     private static int sign = 1;

     /** Actively check whether the given window is ready for input.

      * @param robot

      * @see #isWindowReady

      */

         // Must avoid frame borders, which are insensitive to mouse

         // motion (at least on w32).

             + (width-(insets.left+insets.right))/2;

             + (height-(insets.top+insets.bottom))/2;

             else

         }

                 && isEmptyFrame(w)) {

                 // Force the window to be large enough

                                          insets.left + insets.right + 1);

                                          insets.top + insets.bottom + 1);

                     }

                 });

             }

             // At worst, time out and say the window is ready

             // after the configurable delay

                 }

             };

         }

     }

     /** We can't get any motion events on an empty frame. */

             || insets.left + insets.right == w.getWidth();

     }

 }