/*

 * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.awt;

import java.awt.event.FocusEvent;

import java.awt.event.KeyEvent;

import java.awt.event.WindowEvent;

import java.awt.peer.ComponentPeer;

import java.awt.peer.LightweightPeer;

import java.lang.ref.WeakReference;

import java.util.LinkedList;

import java.util.Iterator;

import java.util.ListIterator;

import java.util.Set;

import sun.util.logging.PlatformLogger;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import sun.awt.CausedFocusEvent;

/**

 * The default KeyboardFocusManager for AWT applications. Focus traversal is

 * done in response to a Component's focus traversal keys, and using a

 * Container's FocusTraversalPolicy.

 * <p>

 * Please see

 * <a href="http://java.sun.com/docs/books/tutorial/uiswing/misc/focus.html">

 * How to Use the Focus Subsystem</a>,

 * a section in <em>The Java Tutorial</em>, and the

 * <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>

 * for more information.

 *

 * @author David Mendenhall

 *

 * @see FocusTraversalPolicy

 * @see Component#setFocusTraversalKeys

 * @see Component#getFocusTraversalKeys

 * @since 1.4

 */

public class DefaultKeyboardFocusManager extends KeyboardFocusManager {

    private static final PlatformLogger focusLog = PlatformLogger.getLogger("java.awt.focus.DefaultKeyboardFocusManager");

    // null weak references to not create too many objects

    private static final WeakReference<Window> NULL_WINDOW_WR =

        new WeakReference<Window>(null);

    private static final WeakReference<Component> NULL_COMPONENT_WR =

        new WeakReference<Component>(null);

    private WeakReference<Window> realOppositeWindowWR = NULL_WINDOW_WR;

    private WeakReference<Component> realOppositeComponentWR = NULL_COMPONENT_WR;

    private int inSendMessage;

    private LinkedList enqueuedKeyEvents = new LinkedList(),

        typeAheadMarkers = new LinkedList();

    private boolean consumeNextKeyTyped;

    private static class TypeAheadMarker {

        long after;

        Component untilFocused;

        TypeAheadMarker(long after, Component untilFocused) {

            this.after = after;

            this.untilFocused = untilFocused;

        }

        /**

         * Returns string representation of the marker

         */

        public String toString() {

            return ">>> Marker after " + after + " on " + untilFocused;

        }

    }

    private Window getOwningFrameDialog(Window window) {

        while (window != null && !(window instanceof Frame ||

                                   window instanceof Dialog)) {

            window = (Window)window.getParent();

        }

        return window;

    }

    /*

     * This series of restoreFocus methods is used for recovering from a

     * rejected focus or activation change. Rejections typically occur when

     * the user attempts to focus a non-focusable Component or Window.

     */

    private void restoreFocus(FocusEvent fe, Window newFocusedWindow) {

        Component realOppositeComponent = this.realOppositeComponentWR.get();

        Component vetoedComponent = fe.getComponent();

        if (newFocusedWindow != null && restoreFocus(newFocusedWindow,

                                                     vetoedComponent, false))

        {

        } else if (realOppositeComponent != null &&

                   doRestoreFocus(realOppositeComponent, vetoedComponent, false)) {

        } else if (fe.getOppositeComponent() != null &&

                   doRestoreFocus(fe.getOppositeComponent(), vetoedComponent, false)) {

        } else {

            clearGlobalFocusOwnerPriv();

        }

    }

    private void restoreFocus(WindowEvent we) {

        Window realOppositeWindow = this.realOppositeWindowWR.get();

        if (realOppositeWindow != null

            && restoreFocus(realOppositeWindow, null, false))

        {

            // do nothing, everything is done in restoreFocus()

        } else if (we.getOppositeWindow() != null &&

                   restoreFocus(we.getOppositeWindow(), null, false))

        {

            // do nothing, everything is done in restoreFocus()

        } else {

            clearGlobalFocusOwnerPriv();

        }

    }

    private boolean restoreFocus(Window aWindow, Component vetoedComponent,

                                 boolean clearOnFailure) {

        Component toFocus =

            KeyboardFocusManager.getMostRecentFocusOwner(aWindow);

        if (toFocus != null && toFocus != vetoedComponent && doRestoreFocus(toFocus, vetoedComponent, false)) {

            return true;

        } else if (clearOnFailure) {

            clearGlobalFocusOwnerPriv();

            return true;

        } else {

            return false;

        }

    }

    private boolean restoreFocus(Component toFocus, boolean clearOnFailure) {

        return doRestoreFocus(toFocus, null, clearOnFailure);

    }

    private boolean doRestoreFocus(Component toFocus, Component vetoedComponent,

                                   boolean clearOnFailure)

    {

        if (toFocus != vetoedComponent && toFocus.isShowing() && toFocus.canBeFocusOwner() &&

            toFocus.requestFocus(false, CausedFocusEvent.Cause.ROLLBACK))

        {

            return true;

        } else {

            Component nextFocus = toFocus.getNextFocusCandidate();

            if (nextFocus != null && nextFocus != vetoedComponent &&

                nextFocus.requestFocusInWindow(CausedFocusEvent.Cause.ROLLBACK))

            {

                return true;

            } else if (clearOnFailure) {

                clearGlobalFocusOwnerPriv();

                return true;

            } else {

                return false;

            }

        }

    }

    /**

     * A special type of SentEvent which updates a counter in the target

     * KeyboardFocusManager if it is an instance of

     * DefaultKeyboardFocusManager.

     */

    private static class DefaultKeyboardFocusManagerSentEvent

        extends SentEvent

    {

        /*

         * serialVersionUID

         */

        private static final long serialVersionUID = -2924743257508701758L;

        public DefaultKeyboardFocusManagerSentEvent(AWTEvent nested,

                                                    AppContext toNotify) {

            super(nested, toNotify);

        }

        public final void dispatch() {

            KeyboardFocusManager manager =

                KeyboardFocusManager.getCurrentKeyboardFocusManager();

            DefaultKeyboardFocusManager defaultManager =

                (manager instanceof DefaultKeyboardFocusManager)

                ? (DefaultKeyboardFocusManager)manager

                : null;

            if (defaultManager != null) {

                synchronized (defaultManager) {

                    defaultManager.inSendMessage++;

                }

            }

            super.dispatch();

            if (defaultManager != null) {

                synchronized (defaultManager) {

                    defaultManager.inSendMessage--;

                }

            }

        }

    }

    /**

     * Sends a synthetic AWTEvent to a Component. If the Component is in

     * the current AppContext, then the event is immediately dispatched.

     * If the Component is in a different AppContext, then the event is

     * posted to the other AppContext's EventQueue, and this method blocks

     * until the event is handled or target AppContext is disposed.

     * Returns true if successfuly dispatched event, false if failed

     * to dispatch.

     */

    static boolean sendMessage(Component target, AWTEvent e) {

        e.isPosted = true;

        AppContext myAppContext = AppContext.getAppContext();

        final AppContext targetAppContext = target.appContext;

        final SentEvent se =

            new DefaultKeyboardFocusManagerSentEvent(e, myAppContext);

        if (myAppContext == targetAppContext) {

            se.dispatch();

        } else {

            if (targetAppContext.isDisposed()) {

                return false;

            }

            SunToolkit.postEvent(targetAppContext, se);

            if (EventQueue.isDispatchThread()) {

                EventDispatchThread edt = (EventDispatchThread)

                    Thread.currentThread();

                edt.pumpEvents(SentEvent.ID, new Conditional() {

                        public boolean evaluate() {

                            return !se.dispatched && !targetAppContext.isDisposed();

                        }

                    });

            } else {

                synchronized (se) {

                    while (!se.dispatched && !targetAppContext.isDisposed()) {

                        try {

                            se.wait(1000);

                        } catch (InterruptedException ie) {

                            break;

                        }

                    }

                }

            }

        }

        return se.dispatched;

    }

    /**

     * This method is called by the AWT event dispatcher requesting that the

     * current KeyboardFocusManager dispatch the specified event on its behalf.

     * DefaultKeyboardFocusManagers dispatch all FocusEvents, all WindowEvents

     * related to focus, and all KeyEvents. These events are dispatched based

     * on the KeyboardFocusManager's notion of the focus owner and the focused

     * and active Windows, sometimes overriding the source of the specified

     * AWTEvent. If this method returns <code>false</code>, then the AWT event

     * dispatcher will attempt to dispatch the event itself.

     *

     * @param e the AWTEvent to be dispatched

     * @return <code>true</code> if this method dispatched the event;

     *         <code>false</code> otherwise

     */

    public boolean dispatchEvent(AWTEvent e) {

        if (focusLog.isLoggable(PlatformLogger.FINE) && (e instanceof WindowEvent || e instanceof FocusEvent)) focusLog.fine("" + e);

        switch (e.getID()) {

            case WindowEvent.WINDOW_GAINED_FOCUS: {

                WindowEvent we = (WindowEvent)e;

                Window oldFocusedWindow = getGlobalFocusedWindow();

                Window newFocusedWindow = we.getWindow();

                if (newFocusedWindow == oldFocusedWindow) {

                    break;

                }

                if (!(newFocusedWindow.isFocusableWindow()

                      && newFocusedWindow.isVisible()

                      && newFocusedWindow.isDisplayable()))

                {

                    // we can not accept focus on such window, so reject it.

                    restoreFocus(we);

                    break;

                }

                // If there exists a current focused window, then notify it

                // that it has lost focus.

                if (oldFocusedWindow != null) {

                    boolean isEventDispatched =

                        sendMessage(oldFocusedWindow,

                                new WindowEvent(oldFocusedWindow,

                                                WindowEvent.WINDOW_LOST_FOCUS,

                                                newFocusedWindow));

                    // Failed to dispatch, clear by ourselfves

                    if (!isEventDispatched) {

                        setGlobalFocusOwner(null);

                        setGlobalFocusedWindow(null);

                    }

                }

                // Because the native libraries do not post WINDOW_ACTIVATED

                // events, we need to synthesize one if the active Window

                // changed.

                Window newActiveWindow =

                    getOwningFrameDialog(newFocusedWindow);

                Window currentActiveWindow = getGlobalActiveWindow();

                if (newActiveWindow != currentActiveWindow) {

                    sendMessage(newActiveWindow,

                                new WindowEvent(newActiveWindow,

                                                WindowEvent.WINDOW_ACTIVATED,

                                                currentActiveWindow));

                    if (newActiveWindow != getGlobalActiveWindow()) {

                        // Activation change was rejected. Unlikely, but

                        // possible.

                        restoreFocus(we);

                        break;

                    }

                }

                setGlobalFocusedWindow(newFocusedWindow);

                if (newFocusedWindow != getGlobalFocusedWindow()) {

                    // Focus change was rejected. Will happen if

                    // newFocusedWindow is not a focusable Window.

                    restoreFocus(we);

                    break;

                }

                // Restore focus to the Component which last held it. We do

                // this here so that client code can override our choice in

                // a WINDOW_GAINED_FOCUS handler.

                //

                // Make sure that the focus change request doesn't change the

                // focused Window in case we are no longer the focused Window

                // when the request is handled.

                if (inSendMessage == 0) {

                    // Identify which Component should initially gain focus

                    // in the Window.

                    //

                    // * If we're in SendMessage, then this is a synthetic

                    //   WINDOW_GAINED_FOCUS message which was generated by a

                    //   the FOCUS_GAINED handler. Allow the Component to

                    //   which the FOCUS_GAINED message was targeted to

                    //   receive the focus.

                    // * Otherwise, look up the correct Component here.

                    //   We don't use Window.getMostRecentFocusOwner because

                    //   window is focused now and 'null' will be returned

                    // Calculating of most recent focus owner and focus

                    // request should be synchronized on KeyboardFocusManager.class

                    // to prevent from thread race when user will request

                    // focus between calculation and our request.

                    // But if focus transfer is synchronous, this synchronization

                    // may cause deadlock, thus we don't synchronize this block.

                    Component toFocus = KeyboardFocusManager.

                        getMostRecentFocusOwner(newFocusedWindow);

                    if ((toFocus == null) &&

                        newFocusedWindow.isFocusableWindow())

                    {

                        toFocus = newFocusedWindow.getFocusTraversalPolicy().

                            getInitialComponent(newFocusedWindow);

                    }

                    Component tempLost = null;

                    synchronized(KeyboardFocusManager.class) {

                        tempLost = newFocusedWindow.setTemporaryLostComponent(null);

                    }

                    // The component which last has the focus when this window was focused

                    // should receive focus first

                    if (focusLog.isLoggable(PlatformLogger.FINER)) {

                        focusLog.finer("tempLost {0}, toFocus {1}",

                                       tempLost, toFocus);

                    }

                    if (tempLost != null) {

                        tempLost.requestFocusInWindow(CausedFocusEvent.Cause.ACTIVATION);

                    }

                    if (toFocus != null && toFocus != tempLost) {

                        // If there is a component which requested focus when this window

                        // was inactive it expects to receive focus after activation.

                        toFocus.requestFocusInWindow(CausedFocusEvent.Cause.ACTIVATION);

                    }

                }

                Window realOppositeWindow = this.realOppositeWindowWR.get();

                if (realOppositeWindow != we.getOppositeWindow()) {

                    we = new WindowEvent(newFocusedWindow,

                                         WindowEvent.WINDOW_GAINED_FOCUS,

                                         realOppositeWindow);

                }

                return typeAheadAssertions(newFocusedWindow, we);

            }

            case WindowEvent.WINDOW_ACTIVATED: {

                WindowEvent we = (WindowEvent)e;

                Window oldActiveWindow = getGlobalActiveWindow();

                Window newActiveWindow = we.getWindow();

                if (oldActiveWindow == newActiveWindow) {

                    break;

                }

                // If there exists a current active window, then notify it that

                // it has lost activation.

                if (oldActiveWindow != null) {

                    boolean isEventDispatched =

                        sendMessage(oldActiveWindow,

                                new WindowEvent(oldActiveWindow,

                                                WindowEvent.WINDOW_DEACTIVATED,

                                                newActiveWindow));

                    // Failed to dispatch, clear by ourselfves

                    if (!isEventDispatched) {

                        setGlobalActiveWindow(null);

                    }

                    if (getGlobalActiveWindow() != null) {

                        // Activation change was rejected. Unlikely, but

                        // possible.

                        break;

                    }

                }

                setGlobalActiveWindow(newActiveWindow);

                if (newActiveWindow != getGlobalActiveWindow()) {

                    // Activation change was rejected. Unlikely, but

                    // possible.

                    break;

                }

                return typeAheadAssertions(newActiveWindow, we);

            }

            case FocusEvent.FOCUS_GAINED: {

                FocusEvent fe = (FocusEvent)e;

                CausedFocusEvent.Cause cause = (fe instanceof CausedFocusEvent) ?

                    ((CausedFocusEvent)fe).getCause() : CausedFocusEvent.Cause.UNKNOWN;

                Component oldFocusOwner = getGlobalFocusOwner();

                Component newFocusOwner = fe.getComponent();

                if (oldFocusOwner == newFocusOwner) {

                    if (focusLog.isLoggable(PlatformLogger.FINE)) {

                        focusLog.fine("Skipping {0} because focus owner is the same", e);

                    }

                    // We can't just drop the event - there could be

                    // type-ahead markers associated with it.

                    dequeueKeyEvents(-1, newFocusOwner);

                    break;

                }

                // If there exists a current focus owner, then notify it that

                // it has lost focus.

                if (oldFocusOwner != null) {

                    boolean isEventDispatched =

                        sendMessage(oldFocusOwner,

                                    new CausedFocusEvent(oldFocusOwner,

                                                   FocusEvent.FOCUS_LOST,

                                                   fe.isTemporary(),

                                                   newFocusOwner, cause));

                    // Failed to dispatch, clear by ourselfves

                    if (!isEventDispatched) {

                        setGlobalFocusOwner(null);

                        if (!fe.isTemporary()) {

                            setGlobalPermanentFocusOwner(null);

                        }

                    }

                }

                // Because the native windowing system has a different notion

                // of the current focus and activation states, it is possible

                // that a Component outside of the focused Window receives a

                // FOCUS_GAINED event. We synthesize a WINDOW_GAINED_FOCUS

                // event in that case.

                final Window newFocusedWindow = SunToolkit.getContainingWindow(newFocusOwner);

                final Window currentFocusedWindow = getGlobalFocusedWindow();

                if (newFocusedWindow != null &&

                    newFocusedWindow != currentFocusedWindow)

                {

                    sendMessage(newFocusedWindow,

                                new WindowEvent(newFocusedWindow,

                                        WindowEvent.WINDOW_GAINED_FOCUS,

                                                currentFocusedWindow));

                    if (newFocusedWindow != getGlobalFocusedWindow()) {

                        // Focus change was rejected. Will happen if

                        // newFocusedWindow is not a focusable Window.

                        // Need to recover type-ahead, but don't bother

                        // restoring focus. That was done by the

                        // WINDOW_GAINED_FOCUS handler

                        dequeueKeyEvents(-1, newFocusOwner);

                        break;

                    }

                }

                if (!(newFocusOwner.isFocusable() && newFocusOwner.isShowing() &&

                    // Refuse focus on a disabled component if the focus event

                    // isn't of UNKNOWN reason (i.e. not a result of a direct request

                    // but traversal, activation or system generated).

                    (newFocusOwner.isEnabled() || cause.equals(CausedFocusEvent.Cause.UNKNOWN))))

                {

                    // we should not accept focus on such component, so reject it.

                    dequeueKeyEvents(-1, newFocusOwner);

                    if (KeyboardFocusManager.isAutoFocusTransferEnabled()) {

                        // If FOCUS_GAINED is for a disposed component (however

                        // it shouldn't happen) its toplevel parent is null. In this

                        // case we have to try to restore focus in the current focused