1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.  Sun designates this

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

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

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

    23  * have any questions.

    24  */

    25 

    26 

    27 package javax.swing;

    28 

    29 import java.awt.event.*;

    30 import java.applet.*;

    31 import java.awt.*;

    32 import java.io.Serializable;

    33 import sun.swing.UIAction;

    34 

    35 /**

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

    37  * <p>

    38  * ToolTipManager contains numerous properties for configuring how long it

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

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

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

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

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

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

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

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

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

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

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

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

    51  *

    52  * @see JComponent#createToolTip

    53  * @author Dave Moore

    54  * @author Rich Schiavi

    55  */

    56 public class ToolTipManager extends MouseAdapter implements MouseMotionListener  {

    57     Timer enterTimer, exitTimer, insideTimer;

    58     String toolTipText;

    59     Point  preferredLocation;

    60     JComponent insideComponent;

    61     MouseEvent mouseEvent;

    62     boolean showImmediately;

    63     final static ToolTipManager sharedInstance = new ToolTipManager();

    64     transient Popup tipWindow;

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

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

    67      */

    68     private Window window;

    69     JToolTip tip;

    70 

    71     private Rectangle popupRect = null;

    72     private Rectangle popupFrameRect = null;

    73 

    74     boolean enabled = true;

    75     private boolean tipShowing = false;

    76 

    77     private FocusListener focusChangeListener = null;

    78     private MouseMotionListener moveBeforeEnterListener = null;

    79     private KeyListener accessibilityKeyListener = null;

    80 

    81     // PENDING(ges)

    82     protected boolean lightWeightPopupEnabled = true;

    83     protected boolean heavyWeightPopupEnabled = false;

    84 

    85     ToolTipManager() {

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

    87         enterTimer.setRepeats(false);

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

    89         exitTimer.setRepeats(false);

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

    91         insideTimer.setRepeats(false);

    92 

    93         moveBeforeEnterListener = new MoveBeforeEnterListener();

    94         accessibilityKeyListener = new AccessibilityKeyListener();

    95     }

    96 

    97     /**

    98      * Enables or disables the tooltip.

    99      *

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

   101      */

   102     public void setEnabled(boolean flag) {

   103         enabled = flag;

   104         if (!flag) {

   105             hideTipWindow();

   106         }

   107     }

   108 

   109     /**

   110      * Returns true if this object is enabled.

   111      *

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

   113      */

   114     public boolean isEnabled() {

   115         return enabled;

   116     }

   117 

   118     /**

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

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

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

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

   123      * application mixes light weight and heavy weights components.

   124      *

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

   126      *

   127      */

   128     public void setLightWeightPopupEnabled(boolean aFlag){

   129         lightWeightPopupEnabled = aFlag;

   130     }

   131 

   132     /**

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

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

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

   136      *

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

   138      */

   139     public boolean isLightWeightPopupEnabled() {

   140         return lightWeightPopupEnabled;

   141     }

   142 

   143 

   144     /**

   145      * Specifies the initial delay value.

   146      *

   147      * @param milliseconds  the number of milliseconds to delay

   148      *        (after the cursor has paused) before displaying the

   149      *        tooltip

   150      * @see #getInitialDelay

   151      */

   152     public void setInitialDelay(int milliseconds) {

   153         enterTimer.setInitialDelay(milliseconds);

   154     }

   155 

   156     /**

   157      * Returns the initial delay value.

   158      *

   159      * @return an integer representing the initial delay value,

   160      *          in milliseconds

   161      * @see #setInitialDelay

   162      */

   163     public int getInitialDelay() {

   164         return enterTimer.getInitialDelay();

   165     }

   166 

   167     /**

   168      * Specifies the dismissal delay value.

   169      *

   170      * @param milliseconds  the number of milliseconds to delay

   171      *        before taking away the tooltip

   172      * @see #getDismissDelay

   173      */

   174     public void setDismissDelay(int milliseconds) {

   175         insideTimer.setInitialDelay(milliseconds);

   176     }

   177 

   178     /**

   179      * Returns the dismissal delay value.

   180      *

   181      * @return an integer representing the dismissal delay value,

   182      *          in milliseconds

   183      * @see #setDismissDelay

   184      */

   185     public int getDismissDelay() {

   186         return insideTimer.getInitialDelay();

   187     }

   188 

   189     /**

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

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

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

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

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

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

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

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

   198      * milliseconds before the tooltip is shown again.

   199      *

   200      * @param milliseconds time in milliseconds

   201      * @see #getReshowDelay

   202      */

   203     public void setReshowDelay(int milliseconds) {

   204         exitTimer.setInitialDelay(milliseconds);

   205     }

   206 

   207     /**

   208      * Returns the reshow delay property.

   209      *

   210      * @return reshown delay property

   211      * @see #setReshowDelay

   212      */

   213     public int getReshowDelay() {

   214         return exitTimer.getInitialDelay();

   215     }

   216 

   217     void showTipWindow() {

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

   219             return;

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

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

   222             KeyboardFocusManager kfm =

   223                     KeyboardFocusManager.getCurrentKeyboardFocusManager();

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

   225                 return;

   226             }

   227         }

   228         if (enabled) {

   229             Dimension size;

   230             Point screenLocation = insideComponent.getLocationOnScreen();

   231             Point location = new Point();

   232             GraphicsConfiguration gc;

   233             gc = insideComponent.getGraphicsConfiguration();

   234             Rectangle sBounds = gc.getBounds();

   235             Insets screenInsets = Toolkit.getDefaultToolkit()

   236                                              .getScreenInsets(gc);

   237             // Take into account screen insets, decrease viewport

   238             sBounds.x += screenInsets.left;

   239             sBounds.y += screenInsets.top;

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

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

   242         boolean leftToRight

   243                 = SwingUtilities.isLeftToRight(insideComponent);

   244 

   245             // Just to be paranoid

   246             hideTipWindow();

   247 

   248             tip = insideComponent.createToolTip();

   249             tip.setTipText(toolTipText);

   250             size = tip.getPreferredSize();

   251 

   252             if(preferredLocation != null) {

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

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

   255         if (!leftToRight) {

   256             location.x -= size.width;

   257         }

   258             } else {

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

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

   261         if (!leftToRight) {

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

   263                 location.x -= size.width;

   264             }

   265         }

   266 

   267             }

   268 

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

   270         if (popupRect == null){

   271         popupRect = new Rectangle();

   272         }

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

   274                 size.width,size.height);

   275 

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

   277             if (location.x < sBounds.x) {

   278                 location.x = sBounds.x;

   279             }

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

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

   282 ;

   283             }

   284             if (location.y < sBounds.y) {

   285                 location.y = sBounds.y;

   286             }

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

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

   289             }

   290 

   291             PopupFactory popupFactory = PopupFactory.getSharedInstance();

   292 

   293             if (lightWeightPopupEnabled) {

   294         int y = getPopupFitHeight(popupRect, insideComponent);

   295         int x = getPopupFitWidth(popupRect,insideComponent);

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

   297             popupFactory.setPopupType(PopupFactory.MEDIUM_WEIGHT_POPUP);

   298         } else {

   299             popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);

   300         }

   301             }

   302             else {

   303                 popupFactory.setPopupType(PopupFactory.MEDIUM_WEIGHT_POPUP);

   304             }

   305         tipWindow = popupFactory.getPopup(insideComponent, tip,

   306                           location.x,

   307                           location.y);

   308             popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);

   309 

   310         tipWindow.show();

   311 

   312             Window componentWindow = SwingUtilities.windowForComponent(

   313                                                     insideComponent);

   314 

   315             window = SwingUtilities.windowForComponent(tip);

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

   317                 window.addMouseListener(this);

   318             }

   319             else {

   320                 window = null;

   321             }

   322 

   323             insideTimer.start();

   324         tipShowing = true;

   325         }

   326     }

   327 

   328     void hideTipWindow() {

   329         if (tipWindow != null) {

   330             if (window != null) {

   331                 window.removeMouseListener(this);

   332                 window = null;

   333             }

   334             tipWindow.hide();

   335             tipWindow = null;

   336             tipShowing = false;

   337             tip = null;

   338             insideTimer.stop();

   339         }

   340     }

   341 

   342     /**

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

   344      *

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

   346      */

   347     public static ToolTipManager sharedInstance() {

   348         return sharedInstance;

   349     }

   350 

   351     // add keylistener here to trigger tip for access

   352     /**

   353      * Registers a component for tooltip management.

   354      * <p>

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

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

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

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

   359      * of invoking this method.

   360      *

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

   362      * @see JComponent#isFocusTraversable

   363      */

   364     public void registerComponent(JComponent component) {

   365         component.removeMouseListener(this);

   366         component.addMouseListener(this);

   367         component.removeMouseMotionListener(moveBeforeEnterListener);

   368         component.addMouseMotionListener(moveBeforeEnterListener);

   369         component.removeKeyListener(accessibilityKeyListener);

   370         component.addKeyListener(accessibilityKeyListener);

   371     }

   372 

   373     /**

   374      * Removes a component from tooltip control.

   375      *

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

   377      */

   378     public void unregisterComponent(JComponent component) {

   379         component.removeMouseListener(this);

   380         component.removeMouseMotionListener(moveBeforeEnterListener);

   381         component.removeKeyListener(accessibilityKeyListener);

   382     }

   383 

   384     // implements java.awt.event.MouseListener

   385     /**

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

   387      *  This determines whether the tool tip should be shown.

   388      *

   389      *  @param event  the event in question

   390      */

   391     public void mouseEntered(MouseEvent event) {

   392         initiateToolTip(event);

   393     }

   394 

   395     private void initiateToolTip(MouseEvent event) {

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

   397             return;

   398         }

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

   400         component.removeMouseMotionListener(moveBeforeEnterListener);

   401 

   402         exitTimer.stop();

   403 

   404         Point location = event.getPoint();

   405         // ensure tooltip shows only in proper place

   406         if (location.x < 0 ||

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

   408             location.y < 0 ||

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

   410             return;

   411         }

   412 

   413         if (insideComponent != null) {

   414             enterTimer.stop();

   415         }

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

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

   418         // ourselves an extra time.

   419         component.removeMouseMotionListener(this);

   420         component.addMouseMotionListener(this);

   421 

   422         boolean sameComponent = (insideComponent == component);

   423 

   424         insideComponent = component;

   425     if (tipWindow != null){

   426             mouseEvent = event;

   427             if (showImmediately) {

   428                 String newToolTipText = component.getToolTipText(event);

   429                 Point newPreferredLocation = component.getToolTipLocation(

   430                                                          event);

   431                 boolean sameLoc = (preferredLocation != null) ?

   432                             preferredLocation.equals(newPreferredLocation) :

   433                             (newPreferredLocation == null);

   434 

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

   436                          !sameLoc) {

   437                     toolTipText = newToolTipText;

   438                     preferredLocation = newPreferredLocation;

   439                     showTipWindow();

   440                 }

   441             } else {

   442                 enterTimer.start();

   443             }

   444         }

   445     }

   446 

   447     // implements java.awt.event.MouseListener

   448     /**

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

   450      *  Any tool tip showing should be hidden.

   451      *

   452      *  @param event  the event in question

   453      */

   454     public void mouseExited(MouseEvent event) {

   455         boolean shouldHide = true;

   456         if (insideComponent == null) {

   457             // Drag exit

   458         }

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

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

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

   462             Container insideComponentWindow = insideComponent.getTopLevelAncestor();

   463             // insideComponent may be removed after tooltip is made visible

   464             if (insideComponentWindow != null) {

   465                 Point location = event.getPoint();

   466                 SwingUtilities.convertPointToScreen(location, window);

   467 

   468                 location.x -= insideComponentWindow.getX();

   469                 location.y -= insideComponentWindow.getY();

   470 

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

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

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

   474                     shouldHide = false;

   475                 } else {

   476                     shouldHide = true;

   477                 }

   478             }

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

   480             Window win = SwingUtilities.getWindowAncestor(insideComponent);

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

   482                 Point location = SwingUtilities.convertPoint(insideComponent,

   483                                                              event.getPoint(),

   484                                                              win);

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

   486                 location.x += bounds.x;

   487                 location.y += bounds.y;

   488 

   489                 Point loc = new Point(0, 0);

   490                 SwingUtilities.convertPointToScreen(loc, tip);

   491                 bounds.x = loc.x;

   492                 bounds.y = loc.y;

   493                 bounds.width = tip.getWidth();

   494                 bounds.height = tip.getHeight();

   495 

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

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

   498                     shouldHide = false;

   499                 } else {

   500                     shouldHide = true;

   501                 }

   502             }

   503         }

   504 

   505         if (shouldHide) {

   506             enterTimer.stop();

   507         if (insideComponent != null) {

   508                 insideComponent.removeMouseMotionListener(this);

   509             }

   510             insideComponent = null;

   511             toolTipText = null;

   512             mouseEvent = null;

   513             hideTipWindow();

   514             exitTimer.restart();

   515         }

   516     }

   517 

   518     // implements java.awt.event.MouseListener

   519     /**

   520      *  Called when the mouse is pressed.

   521      *  Any tool tip showing should be hidden.

   522      *

   523      *  @param event  the event in question

   524      */

   525     public void mousePressed(MouseEvent event) {

   526         hideTipWindow();

   527         enterTimer.stop();

   528         showImmediately = false;

   529         insideComponent = null;

   530         mouseEvent = null;

   531     }

   532 

   533     // implements java.awt.event.MouseMotionListener

   534     /**

   535      *  Called when the mouse is pressed and dragged.

   536      *  Does nothing.

   537      *

   538      *  @param event  the event in question

   539      */

   540     public void mouseDragged(MouseEvent event) {

   541     }

   542 

   543     // implements java.awt.event.MouseMotionListener

   544     /**

   545      *  Called when the mouse is moved.

   546      *  Determines whether the tool tip should be displayed.

   547      *

   548      *  @param event  the event in question

   549      */

   550     public void mouseMoved(MouseEvent event) {

   551         if (tipShowing) {

   552             checkForTipChange(event);

   553         }

   554         else if (showImmediately) {

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

   556             toolTipText = component.getToolTipText(event);

   557             if (toolTipText != null) {

   558                 preferredLocation = component.getToolTipLocation(event);

   559                 mouseEvent = event;

   560                 insideComponent = component;

   561                 exitTimer.stop();

   562                 showTipWindow();

   563             }

   564         }

   565         else {

   566             // Lazily lookup the values from within insideTimerAction

   567             insideComponent = (JComponent)event.getSource();

   568             mouseEvent = event;

   569             toolTipText = null;

   570             enterTimer.restart();

   571         }

   572     }

   573 

   574     /**

   575      * Checks to see if the tooltip needs to be changed in response to

   576      * the MouseMoved event <code>event</code>.

   577      */

   578     private void checkForTipChange(MouseEvent event) {

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

   580         String newText = component.getToolTipText(event);

   581         Point  newPreferredLocation = component.getToolTipLocation(event);

   582 

   583         if (newText != null || newPreferredLocation != null) {

   584             mouseEvent = event;

   585             if (((newText != null && newText.equals(toolTipText)) || newText == null) &&

   586                 ((newPreferredLocation != null && newPreferredLocation.equals(preferredLocation))

   587                  || newPreferredLocation == null)) {

   588                 if (tipWindow != null) {

   589                     insideTimer.restart();

   590                 } else {

   591                     enterTimer.restart();

   592                 }

   593             } else {

   594                 toolTipText = newText;

   595                 preferredLocation = newPreferredLocation;

   596                 if (showImmediately) {

   597                     hideTipWindow();

   598                     showTipWindow();

   599                     exitTimer.stop();

   600                 } else {

   601                     enterTimer.restart();

   602                 }

   603             }

   604         } else {

   605             toolTipText = null;

   606             preferredLocation = null;

   607             mouseEvent = null;

   608             insideComponent = null;

   609             hideTipWindow();

   610             enterTimer.stop();

   611             exitTimer.restart();

   612         }

   613     }

   614 

   615     protected class insideTimerAction implements ActionListener {

   616         public void actionPerformed(ActionEvent e) {

   617             if(insideComponent != null && insideComponent.isShowing()) {

   618                 // Lazy lookup

   619                 if (toolTipText == null && mouseEvent != null) {

   620                     toolTipText = insideComponent.getToolTipText(mouseEvent);

   621                     preferredLocation = insideComponent.getToolTipLocation(

   622                                               mouseEvent);

   623                 }

   624                 if(toolTipText != null) {

   625                     showImmediately = true;

   626                     showTipWindow();

   627                 }

   628                 else {

   629                     insideComponent = null;

   630                     toolTipText = null;

   631                     preferredLocation = null;

   632                     mouseEvent = null;

   633                     hideTipWindow();

   634                 }

   635             }

   636         }

   637     }

   638 

   639     protected class outsideTimerAction implements ActionListener {

   640         public void actionPerformed(ActionEvent e) {

   641             showImmediately = false;

   642         }

   643     }

   644 

   645     protected class stillInsideTimerAction implements ActionListener {

   646         public void actionPerformed(ActionEvent e) {

   647             hideTipWindow();

   648             enterTimer.stop();

   649             showImmediately = false;

   650             insideComponent = null;

   651             mouseEvent = null;

   652         }

   653     }

   654 

   655   /* This listener is registered when the tooltip is first registered

   656    * on a component in order to catch the situation where the tooltip

   657    * was turned on while the mouse was already within the bounds of

   658    * the component.  This way, the tooltip will be initiated on a

   659    * mouse-entered or mouse-moved, whichever occurs first.  Once the

   660    * tooltip has been initiated, we can remove this listener and rely

   661    * solely on mouse-entered to initiate the tooltip.

   662    */

   663     private class MoveBeforeEnterListener extends MouseMotionAdapter {

   664         public void mouseMoved(MouseEvent e) {

   665             initiateToolTip(e);

   666         }

   667     }

   668 

   669     static Frame frameForComponent(Component component) {

   670         while (!(component instanceof Frame)) {

   671             component = component.getParent();

   672         }

   673         return (Frame)component;

   674     }

   675 

   676   private FocusListener createFocusChangeListener(){

   677     return new FocusAdapter(){

   678       public void focusLost(FocusEvent evt){

   679         hideTipWindow();

   680         insideComponent = null;

   681         JComponent c = (JComponent)evt.getSource();

   682         c.removeFocusListener(focusChangeListener);

   683       }

   684     };

   685   }

   686 

   687   // Returns: 0 no adjust

   688   //         -1 can't fit

   689   //         >0 adjust value by amount returned

   690   private int getPopupFitWidth(Rectangle popupRectInScreen, Component invoker){

   691     if (invoker != null){

   692       Container parent;

   693       for (parent = invoker.getParent(); parent != null; parent = parent.getParent()){

   694         // fix internal frame size bug: 4139087 - 4159012

   695         if(parent instanceof JFrame || parent instanceof JDialog ||

   696            parent instanceof JWindow) { // no check for awt.Frame since we use Heavy tips

   697           return getWidthAdjust(parent.getBounds(),popupRectInScreen);

   698         } else if (parent instanceof JApplet || parent instanceof JInternalFrame) {

   699           if (popupFrameRect == null){

   700             popupFrameRect = new Rectangle();

   701           }

   702           Point p = parent.getLocationOnScreen();

   703           popupFrameRect.setBounds(p.x,p.y,

   704                                    parent.getBounds().width,

   705                                    parent.getBounds().height);

   706           return getWidthAdjust(popupFrameRect,popupRectInScreen);

   707         }

   708       }

   709     }

   710     return 0;

   711   }

   712 

   713   // Returns:  0 no adjust

   714   //          >0 adjust by value return

   715   private int getPopupFitHeight(Rectangle popupRectInScreen, Component invoker){

   716     if (invoker != null){

   717       Container parent;

   718       for (parent = invoker.getParent(); parent != null; parent = parent.getParent()){

   719         if(parent instanceof JFrame || parent instanceof JDialog ||

   720            parent instanceof JWindow) {

   721           return getHeightAdjust(parent.getBounds(),popupRectInScreen);

   722         } else if (parent instanceof JApplet || parent instanceof JInternalFrame) {

   723           if (popupFrameRect == null){

   724             popupFrameRect = new Rectangle();

   725           }

   726           Point p = parent.getLocationOnScreen();

   727           popupFrameRect.setBounds(p.x,p.y,

   728                                    parent.getBounds().width,

   729                                    parent.getBounds().height);

   730           return getHeightAdjust(popupFrameRect,popupRectInScreen);

   731         }

   732       }

   733     }

   734     return 0;

   735   }

   736 

   737   private int getHeightAdjust(Rectangle a, Rectangle b){

   738     if (b.y >= a.y && (b.y + b.height) <= (a.y + a.height))

   739       return 0;

   740     else

   741       return (((b.y + b.height) - (a.y + a.height)) + 5);

   742   }

   743 

   744   // Return the number of pixels over the edge we are extending.

   745   // If we are over the edge the ToolTipManager can adjust.

   746   // REMIND: what if the Tooltip is just too big to fit at all - we currently will just clip

   747   private int getWidthAdjust(Rectangle a, Rectangle b){

   748     //    System.out.println("width b.x/b.width: " + b.x + "/" + b.width +

   749     //                 "a.x/a.width: " + a.x + "/" + a.width);

   750     if (b.x >= a.x && (b.x + b.width) <= (a.x + a.width)){

   751       return 0;

   752     }

   753     else {

   754       return (((b.x + b.width) - (a.x +a.width)) + 5);

   755     }

   756   }

   757 

   758 

   759     //

   760     // Actions

   761     //

   762     private void show(JComponent source) {

   763         if (tipWindow != null) { // showing we unshow

   764             hideTipWindow();

   765             insideComponent = null;

   766         }

   767         else {

   768             hideTipWindow(); // be safe

   769             enterTimer.stop();

   770             exitTimer.stop();

   771             insideTimer.stop();

   772             insideComponent = source;

   773             if (insideComponent != null){

   774                 toolTipText = insideComponent.getToolTipText();

   775                 preferredLocation = new Point(10,insideComponent.getHeight()+

   776                                               10);  // manual set

   777                 showTipWindow();

   778                 // put a focuschange listener on to bring the tip down

   779                 if (focusChangeListener == null){

   780                     focusChangeListener = createFocusChangeListener();

   781                 }

   782                 insideComponent.addFocusListener(focusChangeListener);

   783             }

   784         }

   785     }

   786 

   787     private void hide(JComponent source) {

   788         hideTipWindow();

   789         source.removeFocusListener(focusChangeListener);

   790         preferredLocation = null;

   791         insideComponent = null;

   792     }

   793 

   794     /* This listener is registered when the tooltip is first registered

   795      * on a component in order to process accessibility keybindings.

   796      * This will apply globally across L&F

   797      *

   798      * Post Tip: Ctrl+F1

   799      * Unpost Tip: Esc and Ctrl+F1

   800      */

   801     private class AccessibilityKeyListener extends KeyAdapter {

   802         public void keyPressed(KeyEvent e) {

   803             if (!e.isConsumed()) {

   804                 JComponent source = (JComponent) e.getComponent();

   805                 if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {

   806                     if (tipWindow != null) {

   807                         hide(source);

   808                         e.consume();

   809                     }

   810                 } else if (e.getKeyCode() == KeyEvent.VK_F1

   811                         && e.getModifiers() == Event.CTRL_MASK) {

   812                     // Shown tooltip will be hidden

   813                     ToolTipManager.this.show(source);

   814                     e.consume();

   815                 }

   816             }

   817         }

   818     }

   819 }