/*

 * Copyright (c) 2000, 2014, 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.AWTAccessor;

import sun.awt.CausedFocusEvent;

import sun.awt.TimedWindowEvent;

/**

 * 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://docs.oracle.com/javase/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<KeyEvent> enqueuedKeyEvents = new LinkedList<KeyEvent>();

    private LinkedList<TypeAheadMarker> typeAheadMarkers = new LinkedList<TypeAheadMarker>();

    private boolean consumeNextKeyTyped;

    static {

        AWTAccessor.setDefaultKeyboardFocusManagerAccessor(

            new AWTAccessor.DefaultKeyboardFocusManagerAccessor() {

                public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e) {

                    dkfm.consumeNextKeyTyped(e);

                }

            });

    }

    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;

    }

    /*

     * Checks if the focus window event follows key events waiting in the type-ahead

     * queue (if any). This may happen when a user types ahead in the window, the client

     * listeners hang EDT for a while, and the user switches b/w toplevels. In that

     * case the focus window events may be dispatched before the type-ahead events

     * get handled. This may lead to wrong focus behavior and in order to avoid it,

     * the focus window events are reposted to the end of the event queue. See 6981400.

     */

    private boolean repostIfFollowsKeyEvents(WindowEvent e) {

        if (!(e instanceof TimedWindowEvent)) {

            return false;

        }

        TimedWindowEvent we = (TimedWindowEvent)e;

        long time = we.getWhen();

        synchronized (this) {

            KeyEvent ke = enqueuedKeyEvents.isEmpty() ? null : enqueuedKeyEvents.getFirst();

            if (ke != null && time >= ke.getWhen()) {

                TypeAheadMarker marker = typeAheadMarkers.isEmpty() ? null : typeAheadMarkers.getFirst();

                if (marker != null) {

                    Window toplevel = marker.untilFocused.getContainingWindow();

                    // Check that the component awaiting focus belongs to

                    // the current focused window. See 8015454.

                    if (toplevel != null && toplevel.isFocused()) {

                        SunToolkit.postEvent(AppContext.getAppContext(), new SequencedEvent(e));

                        return true;

                    }

                }

            }

        }

        return false;

    }

    /**

     * 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.Level.FINE) && (e instanceof WindowEvent || e instanceof FocusEvent)) {

            focusLog.fine("" + e);

        }

        switch (e.getID()) {

            case WindowEvent.WINDOW_GAINED_FOCUS: {

                if (repostIfFollowsKeyEvents((WindowEvent)e)) {

                    break;

                }

                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.Level.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.Level.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);