/*

 * Copyright 1997-2006 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package javax.swing;

import java.awt.event.*;

import java.applet.*;

import java.awt.*;

import java.io.Serializable;

import sun.swing.UIAction;

/**

 * Manages all the <code>ToolTips</code> in the system.

 * <p>

 * ToolTipManager contains numerous properties for configuring how long it

 * will take for the tooltips to become visible, and how long till they

 * hide. Consider a component that has a different tooltip based on where

 * the mouse is, such as JTree. When the mouse moves into the JTree and

 * over a region that has a valid tooltip, the tooltip will become

 * visibile after <code>initialDelay</code> milliseconds. After

 * <code>dismissDelay</code> milliseconds the tooltip will be hidden. If

 * the mouse is over a region that has a valid tooltip, and the tooltip

 * is currently visible, when the mouse moves to a region that doesn't have

 * a valid tooltip the tooltip will be hidden. If the mouse then moves back

 * into a region that has a valid tooltip within <code>reshowDelay</code>

 * milliseconds, the tooltip will immediately be shown, otherwise the

 * tooltip will be shown again after <code>initialDelay</code> milliseconds.

 *

 * @see JComponent#createToolTip

 * @author Dave Moore

 * @author Rich Schiavi

 */

public class ToolTipManager extends MouseAdapter implements MouseMotionListener  {

    Timer enterTimer, exitTimer, insideTimer;

    String toolTipText;

    Point  preferredLocation;

    JComponent insideComponent;

    MouseEvent mouseEvent;

    boolean showImmediately;

    final static ToolTipManager sharedInstance = new ToolTipManager();

    transient Popup tipWindow;

    /** The Window tip is being displayed in. This will be non-null if

     * the Window tip is in differs from that of insideComponent's Window.

     */

    private Window window;

    JToolTip tip;

    private Rectangle popupRect = null;

    private Rectangle popupFrameRect = null;

    boolean enabled = true;

    private boolean tipShowing = false;

    private FocusListener focusChangeListener = null;

    private MouseMotionListener moveBeforeEnterListener = null;

    private KeyListener accessibilityKeyListener = null;

    // PENDING(ges)

    protected boolean lightWeightPopupEnabled = true;

    protected boolean heavyWeightPopupEnabled = false;

    ToolTipManager() {

        enterTimer = new Timer(750, new insideTimerAction());

        enterTimer.setRepeats(false);

        exitTimer = new Timer(500, new outsideTimerAction());

        exitTimer.setRepeats(false);

        insideTimer = new Timer(4000, new stillInsideTimerAction());

        insideTimer.setRepeats(false);

        moveBeforeEnterListener = new MoveBeforeEnterListener();

        accessibilityKeyListener = new AccessibilityKeyListener();

    }

    /**

     * Enables or disables the tooltip.

     *

     * @param flag  true to enable the tip, false otherwise

     */

    public void setEnabled(boolean flag) {

        enabled = flag;

        if (!flag) {

            hideTipWindow();

        }

    }

    /**

     * Returns true if this object is enabled.

     *

     * @return true if this object is enabled, false otherwise

     */

    public boolean isEnabled() {

        return enabled;

    }

    /**

     * When displaying the <code>JToolTip</code>, the

     * <code>ToolTipManager</code> chooses to use a lightweight

     * <code>JPanel</code> if it fits. This method allows you to

     * disable this feature. You have to do disable it if your

     * application mixes light weight and heavy weights components.

     *

     * @param aFlag true if a lightweight panel is desired, false otherwise

     *

     */

    public void setLightWeightPopupEnabled(boolean aFlag){

        lightWeightPopupEnabled = aFlag;

    }

    /**

     * Returns true if lightweight (all-Java) <code>Tooltips</code>

     * are in use, or false if heavyweight (native peer)

     * <code>Tooltips</code> are being used.

     *

     * @return true if lightweight <code>ToolTips</code> are in use

     */

    public boolean isLightWeightPopupEnabled() {

        return lightWeightPopupEnabled;

    }

    /**

     * Specifies the initial delay value.

     *

     * @param milliseconds  the number of milliseconds to delay

     *        (after the cursor has paused) before displaying the

     *        tooltip

     * @see #getInitialDelay

     */

    public void setInitialDelay(int milliseconds) {

        enterTimer.setInitialDelay(milliseconds);

    }

    /**

     * Returns the initial delay value.

     *

     * @return an integer representing the initial delay value,

     *          in milliseconds

     * @see #setInitialDelay

     */

    public int getInitialDelay() {

        return enterTimer.getInitialDelay();

    }

    /**

     * Specifies the dismissal delay value.

     *

     * @param milliseconds  the number of milliseconds to delay

     *        before taking away the tooltip

     * @see #getDismissDelay

     */

    public void setDismissDelay(int milliseconds) {

        insideTimer.setInitialDelay(milliseconds);

    }

    /**

     * Returns the dismissal delay value.

     *

     * @return an integer representing the dismissal delay value,

     *          in milliseconds

     * @see #setDismissDelay

     */

    public int getDismissDelay() {

        return insideTimer.getInitialDelay();

    }

    /**

     * Used to specify the amount of time before the user has to wait

     * <code>initialDelay</code> milliseconds before a tooltip will be

     * shown. That is, if the tooltip is hidden, and the user moves into

     * a region of the same Component that has a valid tooltip within

     * <code>milliseconds</code> milliseconds the tooltip will immediately

     * be shown. Otherwise, if the user moves into a region with a valid

     * tooltip after <code>milliseconds</code> milliseconds, the user

     * will have to wait an additional <code>initialDelay</code>

     * milliseconds before the tooltip is shown again.

     *

     * @param milliseconds time in milliseconds

     * @see #getReshowDelay

     */

    public void setReshowDelay(int milliseconds) {

        exitTimer.setInitialDelay(milliseconds);

    }

    /**

     * Returns the reshow delay property.

     *

     * @return reshown delay property

     * @see #setReshowDelay

     */

    public int getReshowDelay() {

        return exitTimer.getInitialDelay();

    }

    void showTipWindow() {

        if(insideComponent == null || !insideComponent.isShowing())

            return;

        String mode = UIManager.getString("ToolTipManager.enableToolTipMode");

        if ("activeApplication".equals(mode)) {

            KeyboardFocusManager kfm =

                    KeyboardFocusManager.getCurrentKeyboardFocusManager();

            if (kfm.getFocusedWindow() == null) {

                return;

            }

        }

        if (enabled) {

            Dimension size;

            Point screenLocation = insideComponent.getLocationOnScreen();

            Point location = new Point();

            GraphicsConfiguration gc;

            gc = insideComponent.getGraphicsConfiguration();

            Rectangle sBounds = gc.getBounds();

            Insets screenInsets = Toolkit.getDefaultToolkit()

                                             .getScreenInsets(gc);

            // Take into account screen insets, decrease viewport

            sBounds.x += screenInsets.left;

            sBounds.y += screenInsets.top;

            sBounds.width -= (screenInsets.left + screenInsets.right);

            sBounds.height -= (screenInsets.top + screenInsets.bottom);

        boolean leftToRight

                = SwingUtilities.isLeftToRight(insideComponent);

            // Just to be paranoid

            hideTipWindow();

            tip = insideComponent.createToolTip();

            tip.setTipText(toolTipText);

            size = tip.getPreferredSize();

            if(preferredLocation != null) {

                location.x = screenLocation.x + preferredLocation.x;

                location.y = screenLocation.y + preferredLocation.y;

        if (!leftToRight) {

            location.x -= size.width;

        }

            } else {

                location.x = screenLocation.x + mouseEvent.getX();

                location.y = screenLocation.y + mouseEvent.getY() + 20;

        if (!leftToRight) {

            if(location.x - size.width>=0) {

                location.x -= size.width;

            }

        }

            }

        // we do not adjust x/y when using awt.Window tips

        if (popupRect == null){

        popupRect = new Rectangle();

        }

        popupRect.setBounds(location.x,location.y,

                size.width,size.height);

        // Fit as much of the tooltip on screen as possible

            if (location.x < sBounds.x) {

                location.x = sBounds.x;

            }

            else if (location.x - sBounds.x + size.width > sBounds.width) {

                location.x = sBounds.x + Math.max(0, sBounds.width - size.width)

;

            }

            if (location.y < sBounds.y) {

                location.y = sBounds.y;

            }

            else if (location.y - sBounds.y + size.height > sBounds.height) {

                location.y = sBounds.y + Math.max(0, sBounds.height - size.height);

            }

            PopupFactory popupFactory = PopupFactory.getSharedInstance();

            if (lightWeightPopupEnabled) {

        int y = getPopupFitHeight(popupRect, insideComponent);

        int x = getPopupFitWidth(popupRect,insideComponent);

        if (x>0 || y>0) {

            popupFactory.setPopupType(PopupFactory.MEDIUM_WEIGHT_POPUP);

        } else {

            popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);

        }

            }

            else {

                popupFactory.setPopupType(PopupFactory.MEDIUM_WEIGHT_POPUP);

            }

        tipWindow = popupFactory.getPopup(insideComponent, tip,

                          location.x,

                          location.y);

            popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);

        tipWindow.show();

            Window componentWindow = SwingUtilities.windowForComponent(

                                                    insideComponent);

            window = SwingUtilities.windowForComponent(tip);

            if (window != null && window != componentWindow) {

                window.addMouseListener(this);

            }

            else {

                window = null;

            }

            insideTimer.start();

        tipShowing = true;

        }

    }

    void hideTipWindow() {

        if (tipWindow != null) {

            if (window != null) {

                window.removeMouseListener(this);

                window = null;

            }

            tipWindow.hide();

            tipWindow = null;

            tipShowing = false;

            tip = null;

            insideTimer.stop();

        }

    }

    /**

     * Returns a shared <code>ToolTipManager</code> instance.

     *

     * @return a shared <code>ToolTipManager</code> object

     */

    public static ToolTipManager sharedInstance() {

        return sharedInstance;

    }

    // add keylistener here to trigger tip for access

    /**

     * Registers a component for tooltip management.

     * <p>

     * This will register key bindings to show and hide the tooltip text

     * only if <code>component</code> has focus bindings. This is done

     * so that components that are not normally focus traversable, such

     * as <code>JLabel</code>, are not made focus traversable as a result

     * of invoking this method.

     *

     * @param component  a <code>JComponent</code> object to add

     * @see JComponent#isFocusTraversable

     */

    public void registerComponent(JComponent component) {

        component.removeMouseListener(this);

        component.addMouseListener(this);

        component.removeMouseMotionListener(moveBeforeEnterListener);

        component.addMouseMotionListener(moveBeforeEnterListener);

        component.removeKeyListener(accessibilityKeyListener);

        component.addKeyListener(accessibilityKeyListener);

    }

    /**

     * Removes a component from tooltip control.

     *

     * @param component  a <code>JComponent</code> object to remove

     */

    public void unregisterComponent(JComponent component) {

        component.removeMouseListener(this);

        component.removeMouseMotionListener(moveBeforeEnterListener);

        component.removeKeyListener(accessibilityKeyListener);

    }

    // implements java.awt.event.MouseListener

    /**

     *  Called when the mouse enters the region of a component.

     *  This determines whether the tool tip should be shown.

     *

     *  @param event  the event in question

     */

    public void mouseEntered(MouseEvent event) {

        initiateToolTip(event);

    }

    private void initiateToolTip(MouseEvent event) {

        if (event.getSource() == window) {

            return;

        }

        JComponent component = (JComponent)event.getSource();

        component.removeMouseMotionListener(moveBeforeEnterListener);

        exitTimer.stop();

        Point location = event.getPoint();

        // ensure tooltip shows only in proper place

        if (location.x < 0 ||

            location.x >=component.getWidth() ||

            location.y < 0 ||

            location.y >= component.getHeight()) {

            return;

        }

        if (insideComponent != null) {

            enterTimer.stop();

        }

        // A component in an unactive internal frame is sent two

        // mouseEntered events, make sure we don't end up adding

        // ourselves an extra time.

        component.removeMouseMotionListener(this);

        component.addMouseMotionListener(this);

        boolean sameComponent = (insideComponent == component);

        insideComponent = component;

    if (tipWindow != null){

            mouseEvent = event;

            if (showImmediately) {

                String newToolTipText = component.getToolTipText(event);

                Point newPreferredLocation = component.getToolTipLocation(

                                                         event);

                boolean sameLoc = (preferredLocation != null) ?

                            preferredLocation.equals(newPreferredLocation) :

                            (newPreferredLocation == null);

                if (!sameComponent || !toolTipText.equals(newToolTipText) ||

                         !sameLoc) {

                    toolTipText = newToolTipText;

                    preferredLocation = newPreferredLocation;

                    showTipWindow();

                }

            } else {

                enterTimer.start();

            }

        }

    }

    // implements java.awt.event.MouseListener

    /**

     *  Called when the mouse exits the region of a component.

     *  Any tool tip showing should be hidden.

     *

     *  @param event  the event in question

     */

    public void mouseExited(MouseEvent event) {

        boolean shouldHide = true;

        if (insideComponent == null) {

            // Drag exit

        }

        if (window != null && event.getSource() == window) {

          // if we get an exit and have a heavy window

          // we need to check if it if overlapping the inside component

            Container insideComponentWindow = insideComponent.getTopLevelAncestor();

            // insideComponent may be removed after tooltip is made visible

            if (insideComponentWindow != null) {

                Point location = event.getPoint();

                SwingUtilities.convertPointToScreen(location, window);

                location.x -= insideComponentWindow.getX();

                location.y -= insideComponentWindow.getY();

                location = SwingUtilities.convertPoint(null, location, insideComponent);

                if (location.x >= 0 && location.x < insideComponent.getWidth() &&

                        location.y >= 0 && location.y < insideComponent.getHeight()) {

                    shouldHide = false;

                } else {

                    shouldHide = true;

                }

            }

        } else if(event.getSource() == insideComponent && tipWindow != null) {

            Window win = SwingUtilities.getWindowAncestor(insideComponent);

            if (win != null) {  // insideComponent may have been hidden (e.g. in a menu)

                Point location = SwingUtilities.convertPoint(insideComponent,

                                                             event.getPoint(),

                                                             win);

                Rectangle bounds = insideComponent.getTopLevelAncestor().getBounds();

                location.x += bounds.x;

                location.y += bounds.y;

                Point loc = new Point(0, 0);

                SwingUtilities.convertPointToScreen(loc, tip);

                bounds.x = loc.x;

                bounds.y = loc.y;

                bounds.width = tip.getWidth();

                bounds.height = tip.getHeight();

                if (location.x >= bounds.x && location.x < (bounds.x + bounds.width) &&

                    location.y >= bounds.y && location.y < (bounds.y + bounds.height)) {

                    shouldHide = false;

                } else {

                    shouldHide = true;

                }

            }

        }

        if (shouldHide) {

            enterTimer.stop();

        if (insideComponent != null) {

                insideComponent.removeMouseMotionListener(this);

            }

            insideComponent = null;

            toolTipText = null;

            mouseEvent = null;

            hideTipWindow();

            exitTimer.restart();

        }

    }

    // implements java.awt.event.MouseListener

    /**

     *  Called when the mouse is pressed.

     *  Any tool tip showing should be hidden.

     *

     *  @param event  the event in question

     */

    public void mousePressed(MouseEvent event) {

        hideTipWindow();

        enterTimer.stop();

        showImmediately = false;