1 /*
   2  * Copyright (c) 1997, 2008, Oracle and/or its affiliates. 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javax.swing;
  27 
  28 import java.awt.*;
  29 import java.awt.event.*;
  30 import java.io.IOException;
  31 import java.io.ObjectInputStream;
  32 import java.io.ObjectOutputStream;
  33 import java.io.Serializable;
  34 import java.beans.*;
  35 
  36 import java.util.Locale;
  37 import java.util.Vector;
  38 import java.util.Hashtable;
  39 import javax.accessibility.*;
  40 import javax.swing.plaf.PopupMenuUI;
  41 import javax.swing.plaf.ComponentUI;
  42 import javax.swing.plaf.basic.BasicComboPopup;
  43 import javax.swing.event.*;


  44 import sun.security.util.SecurityConstants;
  45 
  46 import java.applet.Applet;
  47 
  48 /**
  49  * An implementation of a popup menu -- a small window that pops up
  50  * and displays a series of choices. A <code>JPopupMenu</code> is used for the
  51  * menu that appears when the user selects an item on the menu bar.
  52  * It is also used for "pull-right" menu that appears when the
  53  * selects a menu item that activates it. Finally, a <code>JPopupMenu</code>
  54  * can also be used anywhere else you want a menu to appear.  For
  55  * example, when the user right-clicks in a specified area.
  56  * <p>
  57  * For information and examples of using popup menus, see
  58  * <a
  59  href="http://java.sun.com/docs/books/tutorial/uiswing/components/menu.html">How to Use Menus</a>
  60  * in <em>The Java Tutorial.</em>
  61  * <p>
  62  * <strong>Warning:</strong> Swing is not thread safe. For more
  63  * information see <a
  64  * href="package-summary.html#threading">Swing's Threading
  65  * Policy</a>.
  66  * <p>
  67  * <strong>Warning:</strong>
  68  * Serialized objects of this class will not be compatible with
  69  * future Swing releases. The current serialization support is
  70  * appropriate for short term storage or RMI between applications running
  71  * the same version of Swing.  As of 1.4, support for long term storage
  72  * of all JavaBeans<sup><font size="-2">TM</font></sup>
  73  * has been added to the <code>java.beans</code> package.
  74  * Please see {@link java.beans.XMLEncoder}.
  75  *
  76  * @beaninfo
  77  *   attribute: isContainer false
  78  * description: A small window that pops up and displays a series of choices.
  79  *
  80  * @author Georges Saab
  81  * @author David Karlton
  82  * @author Arnaud Weber
  83  */
  84 @SuppressWarnings("serial")
  85 public class JPopupMenu extends JComponent implements Accessible,MenuElement {
  86 
  87     /**
  88      * @see #getUIClassID
  89      * @see #readObject
  90      */
  91     private static final String uiClassID = "PopupMenuUI";
  92 
  93     /**
  94      * Key used in AppContext to determine if light way popups are the default.
  95      */
  96     private static final Object defaultLWPopupEnabledKey =
  97         new StringBuffer("JPopupMenu.defaultLWPopupEnabledKey");
  98 
  99     /** Bug#4425878-Property javax.swing.adjustPopupLocationToFit introduced */
 100     static boolean popupPostionFixDisabled = false;
 101 
 102     static {
 103         popupPostionFixDisabled = java.security.AccessController.doPrivileged(
 104                 new sun.security.action.GetPropertyAction(
 105                 "javax.swing.adjustPopupLocationToFit","")).equals("false");
 106 
 107     }
 108 
 109     transient  Component invoker;
 110     transient  Popup popup;
 111     transient  Frame frame;
 112     private    int desiredLocationX,desiredLocationY;
 113 
 114     private    String     label                   = null;
 115     private    boolean   paintBorder              = true;
 116     private    Insets    margin                   = null;
 117 
 118     /**
 119      * Used to indicate if lightweight popups should be used.
 120      */
 121     private    boolean   lightWeightPopup         = true;
 122 
 123     /*
 124      * Model for the selected subcontrol.
 125      */
 126     private SingleSelectionModel selectionModel;
 127 
 128     /* Lock object used in place of class object for synchronization.
 129      * (4187686)
 130      */
 131     private static final Object classLock = new Object();
 132 
 133     /* diagnostic aids -- should be false for production builds. */
 134     private static final boolean TRACE =   false; // trace creates and disposes
 135     private static final boolean VERBOSE = false; // show reuse hits/misses
 136     private static final boolean DEBUG =   false;  // show bad params, misc.
 137 
 138     /**
 139      *  Sets the default value of the <code>lightWeightPopupEnabled</code>
 140      *  property.
 141      *
 142      *  @param aFlag <code>true</code> if popups can be lightweight,
 143      *               otherwise <code>false</code>
 144      *  @see #getDefaultLightWeightPopupEnabled
 145      *  @see #setLightWeightPopupEnabled
 146      */
 147     public static void setDefaultLightWeightPopupEnabled(boolean aFlag) {
 148         SwingUtilities.appContextPut(defaultLWPopupEnabledKey,
 149                                      Boolean.valueOf(aFlag));
 150     }
 151 
 152     /**
 153      *  Gets the <code>defaultLightWeightPopupEnabled</code> property,
 154      *  which by default is <code>true</code>.
 155      *
 156      *  @return the value of the <code>defaultLightWeightPopupEnabled</code>
 157      *          property
 158      *
 159      *  @see #setDefaultLightWeightPopupEnabled
 160      */
 161     public static boolean getDefaultLightWeightPopupEnabled() {
 162         Boolean b = (Boolean)
 163             SwingUtilities.appContextGet(defaultLWPopupEnabledKey);
 164         if (b == null) {
 165             SwingUtilities.appContextPut(defaultLWPopupEnabledKey,
 166                                          Boolean.TRUE);
 167             return true;
 168         }
 169         return b.booleanValue();
 170     }
 171 
 172     /**
 173      * Constructs a <code>JPopupMenu</code> without an "invoker".
 174      */
 175     public JPopupMenu() {
 176         this(null);
 177     }
 178 
 179     /**
 180      * Constructs a <code>JPopupMenu</code> with the specified title.
 181      *
 182      * @param label  the string that a UI may use to display as a title
 183      * for the popup menu.
 184      */
 185     public JPopupMenu(String label) {
 186         this.label = label;
 187         lightWeightPopup = getDefaultLightWeightPopupEnabled();
 188         setSelectionModel(new DefaultSingleSelectionModel());
 189         enableEvents(AWTEvent.MOUSE_EVENT_MASK);
 190         setFocusTraversalKeysEnabled(false);
 191         updateUI();
 192     }
 193 
 194 
 195 
 196     /**
 197      * Returns the look and feel (L&F) object that renders this component.
 198      *
 199      * @return the <code>PopupMenuUI</code> object that renders this component
 200      */
 201     public PopupMenuUI getUI() {
 202         return (PopupMenuUI)ui;
 203     }
 204 
 205     /**
 206      * Sets the L&F object that renders this component.
 207      *
 208      * @param ui the new <code>PopupMenuUI</code> L&F object
 209      * @see UIDefaults#getUI
 210      * @beaninfo
 211      *        bound: true
 212      *       hidden: true
 213      *    attribute: visualUpdate true
 214      *  description: The UI object that implements the Component's LookAndFeel.
 215      */
 216     public void setUI(PopupMenuUI ui) {
 217         super.setUI(ui);
 218     }
 219 
 220     /**
 221      * Resets the UI property to a value from the current look and feel.
 222      *
 223      * @see JComponent#updateUI
 224      */
 225     public void updateUI() {
 226         setUI((PopupMenuUI)UIManager.getUI(this));
 227     }
 228 
 229 
 230     /**
 231      * Returns the name of the L&F class that renders this component.
 232      *
 233      * @return the string "PopupMenuUI"
 234      * @see JComponent#getUIClassID
 235      * @see UIDefaults#getUI
 236      */
 237     public String getUIClassID() {
 238         return uiClassID;
 239     }
 240 
 241     protected void processFocusEvent(FocusEvent evt) {
 242         super.processFocusEvent(evt);
 243     }
 244 
 245     /**
 246      * Processes key stroke events such as mnemonics and accelerators.
 247      *
 248      * @param evt  the key event to be processed
 249      */
 250     protected void processKeyEvent(KeyEvent evt) {
 251         MenuSelectionManager.defaultManager().processKeyEvent(evt);
 252         if (evt.isConsumed()) {
 253             return;
 254         }
 255         super.processKeyEvent(evt);
 256     }
 257 
 258 
 259     /**
 260      * Returns the model object that handles single selections.
 261      *
 262      * @return the <code>selectionModel</code> property
 263      * @see SingleSelectionModel
 264      */
 265     public SingleSelectionModel getSelectionModel() {
 266         return selectionModel;
 267     }
 268 
 269     /**
 270      * Sets the model object to handle single selections.
 271      *
 272      * @param model the new <code>SingleSelectionModel</code>
 273      * @see SingleSelectionModel
 274      * @beaninfo
 275      * description: The selection model for the popup menu
 276      *      expert: true
 277      */
 278     public void setSelectionModel(SingleSelectionModel model) {
 279         selectionModel = model;
 280     }
 281 
 282     /**
 283      * Appends the specified menu item to the end of this menu.
 284      *
 285      * @param menuItem the <code>JMenuItem</code> to add
 286      * @return the <code>JMenuItem</code> added
 287      */
 288     public JMenuItem add(JMenuItem menuItem) {
 289         super.add(menuItem);
 290         return menuItem;
 291     }
 292 
 293     /**
 294      * Creates a new menu item with the specified text and appends
 295      * it to the end of this menu.
 296      *
 297      * @param s the string for the menu item to be added
 298      */
 299     public JMenuItem add(String s) {
 300         return add(new JMenuItem(s));
 301     }
 302 
 303     /**
 304      * Appends a new menu item to the end of the menu which
 305      * dispatches the specified <code>Action</code> object.
 306      *
 307      * @param a the <code>Action</code> to add to the menu
 308      * @return the new menu item
 309      * @see Action
 310      */
 311     public JMenuItem add(Action a) {
 312         JMenuItem mi = createActionComponent(a);
 313         mi.setAction(a);
 314         add(mi);
 315         return mi;
 316     }
 317 
 318     /**
 319      * Returns an point which has been adjusted to take into account of the
 320      * desktop bounds, taskbar and multi-monitor configuration.
 321      * <p>
 322      * This adustment may be cancelled by invoking the application with
 323      * -Djavax.swing.adjustPopupLocationToFit=false
 324      */
 325     Point adjustPopupLocationToFitScreen(int xPosition, int yPosition) {
 326         Point popupLocation = new Point(xPosition, yPosition);
 327 
 328         if(popupPostionFixDisabled == true || GraphicsEnvironment.isHeadless()) {
 329             return popupLocation;
 330         }
 331 
 332         // Get screen bounds
 333         Rectangle scrBounds;
 334         GraphicsConfiguration gc = getCurrentGraphicsConfiguration(popupLocation);
 335         Toolkit toolkit = Toolkit.getDefaultToolkit();
 336         if(gc != null) {
 337             // If we have GraphicsConfiguration use it to get screen bounds
 338             scrBounds = gc.getBounds();
 339         } else {
 340             // If we don't have GraphicsConfiguration use primary screen
 341             scrBounds = new Rectangle(toolkit.getScreenSize());
 342         }
 343 
 344         // Calculate the screen size that popup should fit
 345         Dimension popupSize = JPopupMenu.this.getPreferredSize();
 346         long popupRightX = (long)popupLocation.x + (long)popupSize.width;
 347         long popupBottomY = (long)popupLocation.y + (long)popupSize.height;
 348         int scrWidth = scrBounds.width;
 349         int scrHeight = scrBounds.height;

 350         if (!canPopupOverlapTaskBar()) {
 351             // Insets include the task bar. Take them into account.
 352             Insets scrInsets = toolkit.getScreenInsets(gc);
 353             scrBounds.x += scrInsets.left;
 354             scrBounds.y += scrInsets.top;
 355             scrWidth -= scrInsets.left + scrInsets.right;
 356             scrHeight -= scrInsets.top + scrInsets.bottom;
 357         }
 358         int scrRightX = scrBounds.x + scrWidth;
 359         int scrBottomY = scrBounds.y + scrHeight;
 360 
 361         // Ensure that popup menu fits the screen
 362         if (popupRightX > (long) scrRightX) {
 363             popupLocation.x = scrRightX - popupSize.width;
 364         }
 365 
 366         if (popupBottomY > (long) scrBottomY) {
 367             popupLocation.y = scrBottomY - popupSize.height;
 368         }
 369 
 370         if (popupLocation.x < scrBounds.x) {
 371             popupLocation.x = scrBounds.x;
 372         }
 373 
 374         if (popupLocation.y < scrBounds.y) {
 375             popupLocation.y = scrBounds.y;
 376         }
 377 
 378         return popupLocation;
 379     }
 380 
 381     /**
 382      * Tries to find GraphicsConfiguration
 383      * that contains the mouse cursor position.
 384      * Can return null.
 385      */
 386     private GraphicsConfiguration getCurrentGraphicsConfiguration(
 387             Point popupLocation) {
 388         GraphicsConfiguration gc = null;
 389         GraphicsEnvironment ge =
 390             GraphicsEnvironment.getLocalGraphicsEnvironment();
 391         GraphicsDevice[] gd = ge.getScreenDevices();
 392         for(int i = 0; i < gd.length; i++) {
 393             if(gd[i].getType() == GraphicsDevice.TYPE_RASTER_SCREEN) {
 394                 GraphicsConfiguration dgc =
 395                     gd[i].getDefaultConfiguration();
 396                 if(dgc.getBounds().contains(popupLocation)) {
 397                     gc = dgc;
 398                     break;
 399                 }
 400             }
 401         }
 402         // If not found and we have invoker, ask invoker about his gc
 403         if(gc == null && getInvoker() != null) {
 404             gc = getInvoker().getGraphicsConfiguration();
 405         }
 406         return gc;
 407     }
 408 
 409     /**
 410      * Checks that there are enough security permissions
 411      * to make popup "always on top", which allows to show it above the task bar.
 412      */
 413     static boolean canPopupOverlapTaskBar() {
 414         boolean result = true;
 415         try {
 416             SecurityManager sm = System.getSecurityManager();
 417             if (sm != null) {
 418                 sm.checkPermission(
 419                     SecurityConstants.AWT.SET_WINDOW_ALWAYS_ON_TOP_PERMISSION);
 420             }
 421         } catch (SecurityException se) {
 422             // There is no permission to show popups over the task bar
 423             result = false;
 424         }

 425         return result;
 426     }
 427 
 428 
 429     /**
 430      * Factory method which creates the <code>JMenuItem</code> for
 431      * <code>Actions</code> added to the <code>JPopupMenu</code>.
 432      *
 433      * @param a the <code>Action</code> for the menu item to be added
 434      * @return the new menu item
 435      * @see Action
 436      *
 437      * @since 1.3
 438      */
 439     protected JMenuItem createActionComponent(Action a) {
 440         JMenuItem mi = new JMenuItem() {
 441             protected PropertyChangeListener createActionPropertyChangeListener(Action a) {
 442                 PropertyChangeListener pcl = createActionChangeListener(this);
 443                 if (pcl == null) {
 444                     pcl = super.createActionPropertyChangeListener(a);
 445                 }
 446                 return pcl;
 447             }
 448         };
 449         mi.setHorizontalTextPosition(JButton.TRAILING);
 450         mi.setVerticalTextPosition(JButton.CENTER);
 451         return mi;
 452     }
 453 
 454     /**
 455      * Returns a properly configured <code>PropertyChangeListener</code>
 456      * which updates the control as changes to the <code>Action</code> occur.
 457      */
 458     protected PropertyChangeListener createActionChangeListener(JMenuItem b) {
 459         return b.createActionPropertyChangeListener0(b.getAction());
 460     }
 461 
 462     /**
 463      * Removes the component at the specified index from this popup menu.
 464      *
 465      * @param       pos the position of the item to be removed
 466      * @exception   IllegalArgumentException if the value of
 467      *                          <code>pos</code> < 0, or if the value of
 468      *                          <code>pos</code> is greater than the
 469      *                          number of items
 470      */
 471     public void remove(int pos) {
 472         if (pos < 0) {
 473             throw new IllegalArgumentException("index less than zero.");
 474         }
 475         if (pos > getComponentCount() -1) {
 476             throw new IllegalArgumentException("index greater than the number of items.");
 477         }
 478         super.remove(pos);
 479     }
 480 
 481     /**
 482      * Sets the value of the <code>lightWeightPopupEnabled</code> property,
 483      * which by default is <code>true</code>.
 484      * By default, when a look and feel displays a popup,
 485      * it can choose to
 486      * use a lightweight (all-Java) popup.
 487      * Lightweight popup windows are more efficient than heavyweight
 488      * (native peer) windows,
 489      * but lightweight and heavyweight components do not mix well in a GUI.
 490      * If your application mixes lightweight and heavyweight components,
 491      * you should disable lightweight popups.
 492      * Some look and feels might always use heavyweight popups,
 493      * no matter what the value of this property.
 494      *
 495      * @param aFlag  <code>false</code> to disable lightweight popups
 496      * @beaninfo
 497      * description: Determines whether lightweight popups are used when possible
 498      *      expert: true
 499      *
 500      * @see #isLightWeightPopupEnabled
 501      */
 502     public void setLightWeightPopupEnabled(boolean aFlag) {
 503         // NOTE: this use to set the flag on a shared JPopupMenu, which meant
 504         // this effected ALL JPopupMenus.
 505         lightWeightPopup = aFlag;
 506     }
 507 
 508     /**
 509      * Gets the <code>lightWeightPopupEnabled</code> property.
 510      *
 511      * @return the value of the <code>lightWeightPopupEnabled</code> property
 512      * @see #setLightWeightPopupEnabled
 513      */
 514     public boolean isLightWeightPopupEnabled() {
 515         return lightWeightPopup;
 516     }
 517 
 518     /**
 519      * Returns the popup menu's label
 520      *
 521      * @return a string containing the popup menu's label
 522      * @see #setLabel
 523      */
 524     public String getLabel() {
 525         return label;
 526     }
 527 
 528     /**
 529      * Sets the popup menu's label.  Different look and feels may choose
 530      * to display or not display this.
 531      *
 532      * @param label a string specifying the label for the popup menu
 533      *
 534      * @see #setLabel
 535      * @beaninfo
 536      * description: The label for the popup menu.
 537      *       bound: true
 538      */
 539     public void setLabel(String label) {
 540         String oldValue = this.label;
 541         this.label = label;
 542         firePropertyChange("label", oldValue, label);
 543         if (accessibleContext != null) {
 544             accessibleContext.firePropertyChange(
 545                 AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
 546                 oldValue, label);
 547         }
 548         invalidate();
 549         repaint();
 550     }
 551 
 552     /**
 553      * Appends a new separator at the end of the menu.
 554      */
 555     public void addSeparator() {
 556         add( new JPopupMenu.Separator() );
 557     }
 558 
 559     /**
 560      * Inserts a menu item for the specified <code>Action</code> object at
 561      * a given position.
 562      *
 563      * @param a  the <code>Action</code> object to insert
 564      * @param index      specifies the position at which to insert the
 565      *                   <code>Action</code>, where 0 is the first
 566      * @exception IllegalArgumentException if <code>index</code> < 0
 567      * @see Action
 568      */
 569     public void insert(Action a, int index) {
 570         JMenuItem mi = createActionComponent(a);
 571         mi.setAction(a);
 572         insert(mi, index);
 573     }
 574 
 575     /**
 576      * Inserts the specified component into the menu at a given
 577      * position.
 578      *
 579      * @param component  the <code>Component</code> to insert
 580      * @param index      specifies the position at which
 581      *                   to insert the component, where 0 is the first
 582      * @exception IllegalArgumentException if <code>index</code> < 0
 583      */
 584     public void insert(Component component, int index) {
 585         if (index < 0) {
 586             throw new IllegalArgumentException("index less than zero.");
 587         }
 588 
 589         int nitems = getComponentCount();
 590         // PENDING(ges): Why not use an array?
 591         Vector<Component> tempItems = new Vector<Component>();
 592 
 593         /* Remove the item at index, nitems-index times
 594            storing them in a temporary vector in the
 595            order they appear on the menu.
 596            */
 597         for (int i = index ; i < nitems; i++) {
 598             tempItems.addElement(getComponent(index));
 599             remove(index);
 600         }
 601 
 602         add(component);
 603 
 604         /* Add the removed items back to the menu, they are
 605            already in the correct order in the temp vector.
 606            */
 607         for (Component tempItem : tempItems) {
 608             add(tempItem);
 609         }
 610     }
 611 
 612     /**
 613      *  Adds a <code>PopupMenu</code> listener.
 614      *
 615      *  @param l  the <code>PopupMenuListener</code> to add
 616      */
 617     public void addPopupMenuListener(PopupMenuListener l) {
 618         listenerList.add(PopupMenuListener.class,l);
 619     }
 620 
 621     /**
 622      * Removes a <code>PopupMenu</code> listener.
 623      *
 624      * @param l  the <code>PopupMenuListener</code> to remove
 625      */
 626     public void removePopupMenuListener(PopupMenuListener l) {
 627         listenerList.remove(PopupMenuListener.class,l);
 628     }
 629 
 630     /**
 631      * Returns an array of all the <code>PopupMenuListener</code>s added
 632      * to this JMenuItem with addPopupMenuListener().
 633      *
 634      * @return all of the <code>PopupMenuListener</code>s added or an empty
 635      *         array if no listeners have been added
 636      * @since 1.4
 637      */
 638     public PopupMenuListener[] getPopupMenuListeners() {
 639         return listenerList.getListeners(PopupMenuListener.class);
 640     }
 641 
 642     /**
 643      * Adds a <code>MenuKeyListener</code> to the popup menu.
 644      *
 645      * @param l the <code>MenuKeyListener</code> to be added
 646      * @since 1.5
 647      */
 648     public void addMenuKeyListener(MenuKeyListener l) {
 649         listenerList.add(MenuKeyListener.class, l);
 650     }
 651 
 652     /**
 653      * Removes a <code>MenuKeyListener</code> from the popup menu.
 654      *
 655      * @param l the <code>MenuKeyListener</code> to be removed
 656      * @since 1.5
 657      */
 658     public void removeMenuKeyListener(MenuKeyListener l) {
 659         listenerList.remove(MenuKeyListener.class, l);
 660     }
 661 
 662     /**
 663      * Returns an array of all the <code>MenuKeyListener</code>s added
 664      * to this JPopupMenu with addMenuKeyListener().
 665      *
 666      * @return all of the <code>MenuKeyListener</code>s added or an empty
 667      *         array if no listeners have been added
 668      * @since 1.5
 669      */
 670     public MenuKeyListener[] getMenuKeyListeners() {
 671         return listenerList.getListeners(MenuKeyListener.class);
 672     }
 673 
 674     /**
 675      * Notifies <code>PopupMenuListener</code>s that this popup menu will
 676      * become visible.
 677      */
 678     protected void firePopupMenuWillBecomeVisible() {
 679         Object[] listeners = listenerList.getListenerList();
 680         PopupMenuEvent e=null;
 681         for (int i = listeners.length-2; i>=0; i-=2) {
 682             if (listeners[i]==PopupMenuListener.class) {
 683                 if (e == null)
 684                     e = new PopupMenuEvent(this);
 685                 ((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeVisible(e);
 686             }
 687         }
 688     }
 689 
 690     /**
 691      * Notifies <code>PopupMenuListener</code>s that this popup menu will
 692      * become invisible.
 693      */
 694     protected void firePopupMenuWillBecomeInvisible() {
 695         Object[] listeners = listenerList.getListenerList();
 696         PopupMenuEvent e=null;
 697         for (int i = listeners.length-2; i>=0; i-=2) {
 698             if (listeners[i]==PopupMenuListener.class) {
 699                 if (e == null)
 700                     e = new PopupMenuEvent(this);
 701                 ((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeInvisible(e);
 702             }
 703         }
 704     }
 705 
 706     /**
 707      * Notifies <code>PopupMenuListeners</code> that this popup menu is
 708      * cancelled.
 709      */
 710     protected void firePopupMenuCanceled() {
 711         Object[] listeners = listenerList.getListenerList();
 712         PopupMenuEvent e=null;
 713         for (int i = listeners.length-2; i>=0; i-=2) {
 714             if (listeners[i]==PopupMenuListener.class) {
 715                 if (e == null)
 716                     e = new PopupMenuEvent(this);
 717                 ((PopupMenuListener)listeners[i+1]).popupMenuCanceled(e);
 718             }
 719         }
 720     }
 721 
 722     /**
 723      * Always returns true since popups, by definition, should always
 724      * be on top of all other windows.
 725      * @return true
 726      */
 727     // package private
 728     boolean alwaysOnTop() {
 729         return true;
 730     }
 731 
 732     /**
 733      * Lays out the container so that it uses the minimum space
 734      * needed to display its contents.
 735      */
 736     public void pack() {
 737         if(popup != null) {
 738             Dimension pref = getPreferredSize();
 739 
 740             if (pref == null || pref.width != getWidth() ||
 741                                 pref.height != getHeight()) {
 742                 popup = getPopup();
 743             } else {
 744                 validate();
 745             }
 746         }
 747     }
 748 
 749     /**
 750      * Sets the visibility of the popup menu.
 751      *
 752      * @param b true to make the popup visible, or false to
 753      *          hide it
 754      * @beaninfo
 755      *           bound: true
 756      *     description: Makes the popup visible
 757      */
 758     public void setVisible(boolean b) {
 759         if (DEBUG) {
 760             System.out.println("JPopupMenu.setVisible " + b);
 761         }
 762 
 763         // Is it a no-op?
 764         if (b == isVisible())
 765             return;
 766 
 767         // if closing, first close all Submenus
 768         if (b == false) {
 769 
 770             // 4234793: This is a workaround because JPopupMenu.firePopupMenuCanceled is
 771             // a protected method and cannot be called from BasicPopupMenuUI directly
 772             // The real solution could be to make
 773             // firePopupMenuCanceled public and call it directly.
 774             Boolean doCanceled = (Boolean)getClientProperty("JPopupMenu.firePopupMenuCanceled");
 775             if (doCanceled != null && doCanceled == Boolean.TRUE) {
 776                 putClientProperty("JPopupMenu.firePopupMenuCanceled", Boolean.FALSE);
 777                 firePopupMenuCanceled();
 778             }
 779             getSelectionModel().clearSelection();
 780 
 781         } else {
 782             // This is a popup menu with MenuElement children,
 783             // set selection path before popping up!
 784             if (isPopupMenu()) {
 785                 MenuElement me[] = new MenuElement[1];
 786                 me[0] = this;
 787                 MenuSelectionManager.defaultManager().setSelectedPath(me);
 788             }
 789         }
 790 
 791         if(b) {
 792             firePopupMenuWillBecomeVisible();
 793             popup = getPopup();
 794             firePropertyChange("visible", Boolean.FALSE, Boolean.TRUE);
 795 
 796 
 797         } else if(popup != null) {
 798             firePopupMenuWillBecomeInvisible();
 799             popup.hide();
 800             popup = null;
 801             firePropertyChange("visible", Boolean.TRUE, Boolean.FALSE);
 802             // 4694797: When popup menu is made invisible, selected path
 803             // should be cleared
 804             if (isPopupMenu()) {
 805                 MenuSelectionManager.defaultManager().clearSelectedPath();
 806             }
 807         }
 808     }
 809 
 810     /**
 811      * Returns a <code>Popup</code> instance from the
 812      * <code>PopupMenuUI</code> that has had <code>show</code> invoked on
 813      * it. If the current <code>popup</code> is non-null,
 814      * this will invoke <code>dispose</code> of it, and then
 815      * <code>show</code> the new one.
 816      * <p>
 817      * This does NOT fire any events, it is up the caller to dispatch
 818      * the necessary events.
 819      */
 820     private Popup getPopup() {
 821         Popup oldPopup = popup;
 822 
 823         if (oldPopup != null) {
 824             oldPopup.hide();
 825         }
 826         PopupFactory popupFactory = PopupFactory.getSharedInstance();
 827 
 828         if (isLightWeightPopupEnabled()) {
 829             popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);
 830         }
 831         else {
 832             popupFactory.setPopupType(PopupFactory.MEDIUM_WEIGHT_POPUP);
 833         }
 834 
 835         // adjust the location of the popup
 836         Point p = adjustPopupLocationToFitScreen(desiredLocationX,desiredLocationY);
 837         desiredLocationX = p.x;
 838         desiredLocationY = p.y;
 839 
 840         Popup newPopup = getUI().getPopup(this, desiredLocationX,
 841                                           desiredLocationY);
 842 
 843         popupFactory.setPopupType(PopupFactory.LIGHT_WEIGHT_POPUP);
 844         newPopup.show();
 845         return newPopup;
 846     }
 847 
 848     /**
 849      * Returns true if the popup menu is visible (currently
 850      * being displayed).
 851      */
 852     public boolean isVisible() {
 853         return popup != null;
 854     }
 855 
 856     /**
 857      * Sets the location of the upper left corner of the
 858      * popup menu using x, y coordinates.
 859      *
 860      * @param x the x coordinate of the popup's new position
 861      *          in the screen's coordinate space
 862      * @param y the y coordinate of the popup's new position
 863      *          in the screen's coordinate space
 864      * @beaninfo
 865      * description: The location of the popup menu.
 866      */
 867     public void setLocation(int x, int y) {
 868         int oldX = desiredLocationX;
 869         int oldY = desiredLocationY;
 870 
 871         desiredLocationX = x;
 872         desiredLocationY = y;
 873         if(popup != null && (x != oldX || y != oldY)) {
 874             popup = getPopup();
 875         }
 876     }
 877 
 878     /**
 879      * Returns true if the popup menu is a standalone popup menu
 880      * rather than the submenu of a <code>JMenu</code>.
 881      *
 882      * @return true if this menu is a standalone popup menu, otherwise false
 883      */
 884     private boolean isPopupMenu() {
 885         return  ((invoker != null) && !(invoker instanceof JMenu));
 886     }
 887 
 888     /**
 889      * Returns the component which is the 'invoker' of this
 890      * popup menu.
 891      *
 892      * @return the <code>Component</code> in which the popup menu is displayed
 893      */
 894     public Component getInvoker() {
 895         return this.invoker;
 896     }
 897 
 898     /**
 899      * Sets the invoker of this popup menu -- the component in which
 900      * the popup menu menu is to be displayed.
 901      *
 902      * @param invoker the <code>Component</code> in which the popup
 903      *          menu is displayed
 904      * @beaninfo
 905      * description: The invoking component for the popup menu
 906      *      expert: true
 907      */
 908     public void setInvoker(Component invoker) {
 909         Component oldInvoker = this.invoker;
 910         this.invoker = invoker;
 911         if ((oldInvoker != this.invoker) && (ui != null)) {
 912             ui.uninstallUI(this);
 913             ui.installUI(this);
 914         }
 915         invalidate();
 916     }
 917 
 918     /**
 919      * Displays the popup menu at the position x,y in the coordinate
 920      * space of the component invoker.
 921      *
 922      * @param invoker the component in whose space the popup menu is to appear
 923      * @param x the x coordinate in invoker's coordinate space at which
 924      * the popup menu is to be displayed
 925      * @param y the y coordinate in invoker's coordinate space at which
 926      * the popup menu is to be displayed
 927      */
 928     public void show(Component invoker, int x, int y) {
 929         if (DEBUG) {
 930             System.out.println("in JPopupMenu.show " );
 931         }
 932         setInvoker(invoker);
 933         Frame newFrame = getFrame(invoker);
 934         if (newFrame != frame) {
 935             // Use the invoker's frame so that events
 936             // are propagated properly
 937             if (newFrame!=null) {
 938                 this.frame = newFrame;
 939                 if(popup != null) {
 940                     setVisible(false);
 941                 }
 942             }
 943         }
 944         Point invokerOrigin;
 945         if (invoker != null) {
 946             invokerOrigin = invoker.getLocationOnScreen();
 947 
 948             // To avoid integer overflow
 949             long lx, ly;
 950             lx = ((long) invokerOrigin.x) +
 951                  ((long) x);
 952             ly = ((long) invokerOrigin.y) +
 953                  ((long) y);
 954             if(lx > Integer.MAX_VALUE) lx = Integer.MAX_VALUE;
 955             if(lx < Integer.MIN_VALUE) lx = Integer.MIN_VALUE;
 956             if(ly > Integer.MAX_VALUE) ly = Integer.MAX_VALUE;
 957             if(ly < Integer.MIN_VALUE) ly = Integer.MIN_VALUE;
 958 
 959             setLocation((int) lx, (int) ly);
 960         } else {
 961             setLocation(x, y);
 962         }
 963         setVisible(true);
 964     }
 965 
 966     /**
 967      * Returns the popup menu which is at the root of the menu system
 968      * for this popup menu.
 969      *
 970      * @return the topmost grandparent <code>JPopupMenu</code>
 971      */
 972     JPopupMenu getRootPopupMenu() {
 973         JPopupMenu mp = this;
 974         while((mp!=null) && (mp.isPopupMenu()!=true) &&
 975               (mp.getInvoker() != null) &&
 976               (mp.getInvoker().getParent() != null) &&
 977               (mp.getInvoker().getParent() instanceof JPopupMenu)
 978               ) {
 979             mp = (JPopupMenu) mp.getInvoker().getParent();
 980         }
 981         return mp;
 982     }
 983 
 984     /**
 985      * Returns the component at the specified index.
 986      *
 987      * @param i  the index of the component, where 0 is the first
 988      * @return the <code>Component</code> at that index
 989      * @deprecated replaced by {@link java.awt.Container#getComponent(int)}
 990      */
 991     @Deprecated
 992     public Component getComponentAtIndex(int i) {
 993         return getComponent(i);
 994     }
 995 
 996     /**
 997      * Returns the index of the specified component.
 998      *
 999      * @param  c the <code>Component</code> to find
1000      * @return the index of the component, where 0 is the first;
1001      *         or -1 if the component is not found
1002      */
1003     public int getComponentIndex(Component c) {
1004         int ncomponents = this.getComponentCount();
1005         Component[] component = this.getComponents();
1006         for (int i = 0 ; i < ncomponents ; i++) {
1007             Component comp = component[i];
1008             if (comp == c)
1009                 return i;
1010         }
1011         return -1;
1012     }
1013 
1014     /**
1015      * Sets the size of the Popup window using a <code>Dimension</code> object.
1016      * This is equivalent to <code>setPreferredSize(d)</code>.
1017      *
1018      * @param d   the <code>Dimension</code> specifying the new size
1019      * of this component.
1020      * @beaninfo
1021      * description: The size of the popup menu
1022      */
1023     public void setPopupSize(Dimension d) {
1024         Dimension oldSize = getPreferredSize();
1025 
1026         setPreferredSize(d);
1027         if (popup != null) {
1028             Dimension newSize = getPreferredSize();
1029 
1030             if (!oldSize.equals(newSize)) {
1031                 popup = getPopup();
1032             }
1033         }
1034     }
1035 
1036     /**
1037      * Sets the size of the Popup window to the specified width and
1038      * height. This is equivalent to
1039      *  <code>setPreferredSize(new Dimension(width, height))</code>.
1040      *
1041      * @param width the new width of the Popup in pixels
1042      * @param height the new height of the Popup in pixels
1043      * @beaninfo
1044      * description: The size of the popup menu
1045      */
1046     public void setPopupSize(int width, int height) {
1047         setPopupSize(new Dimension(width, height));
1048     }
1049 
1050     /**
1051      * Sets the currently selected component,  This will result
1052      * in a change to the selection model.
1053      *
1054      * @param sel the <code>Component</code> to select
1055      * @beaninfo
1056      * description: The selected component on the popup menu
1057      *      expert: true
1058      *      hidden: true
1059      */
1060     public void setSelected(Component sel) {
1061         SingleSelectionModel model = getSelectionModel();
1062         int index = getComponentIndex(sel);
1063         model.setSelectedIndex(index);
1064     }
1065 
1066     /**
1067      * Checks whether the border should be painted.
1068      *
1069      * @return true if the border is painted, false otherwise
1070      * @see #setBorderPainted
1071      */
1072     public boolean isBorderPainted() {
1073         return paintBorder;
1074     }
1075 
1076     /**
1077      * Sets whether the border should be painted.
1078      *
1079      * @param b if true, the border is painted.
1080      * @see #isBorderPainted
1081      * @beaninfo
1082      * description: Is the border of the popup menu painted
1083      */
1084     public void setBorderPainted(boolean b) {
1085         paintBorder = b;
1086         repaint();
1087     }
1088 
1089     /**
1090      * Paints the popup menu's border if the <code>borderPainted</code>
1091      * property is <code>true</code>.
1092      * @param g  the <code>Graphics</code> object
1093      *
1094      * @see JComponent#paint
1095      * @see JComponent#setBorder
1096      */
1097     protected void paintBorder(Graphics g) {
1098         if (isBorderPainted()) {
1099             super.paintBorder(g);
1100         }
1101     }
1102 
1103     /**
1104      * Returns the margin, in pixels, between the popup menu's border and
1105      * its containees.
1106      *
1107      * @return an <code>Insets</code> object containing the margin values.
1108      */
1109     public Insets getMargin() {
1110         if(margin == null) {
1111             return new Insets(0,0,0,0);
1112         } else {
1113             return margin;
1114         }
1115     }
1116 
1117 
1118     /**
1119      * Examines the list of menu items to determine whether
1120      * <code>popup</code> is a popup menu.
1121      *
1122      * @param popup  a <code>JPopupMenu</code>
1123      * @return true if <code>popup</code>
1124      */
1125     boolean isSubPopupMenu(JPopupMenu popup) {
1126         int ncomponents = this.getComponentCount();
1127         Component[] component = this.getComponents();
1128         for (int i = 0 ; i < ncomponents ; i++) {
1129             Component comp = component[i];
1130             if (comp instanceof JMenu) {
1131                 JMenu menu = (JMenu)comp;
1132                 JPopupMenu subPopup = menu.getPopupMenu();
1133                 if (subPopup == popup)
1134                     return true;
1135                 if (subPopup.isSubPopupMenu(popup))
1136                     return true;
1137             }
1138         }
1139         return false;
1140     }
1141 
1142 
1143     private static Frame getFrame(Component c) {
1144         Component w = c;
1145 
1146         while(!(w instanceof Frame) && (w!=null)) {
1147             w = w.getParent();
1148         }
1149         return (Frame)w;
1150     }
1151 
1152 
1153     /**
1154      * Returns a string representation of this <code>JPopupMenu</code>.
1155      * This method
1156      * is intended to be used only for debugging purposes, and the
1157      * content and format of the returned string may vary between
1158      * implementations. The returned string may be empty but may not
1159      * be <code>null</code>.
1160      *
1161      * @return  a string representation of this <code>JPopupMenu</code>.
1162      */
1163     protected String paramString() {
1164         String labelString = (label != null ?
1165                               label : "");
1166         String paintBorderString = (paintBorder ?
1167                                     "true" : "false");
1168         String marginString = (margin != null ?
1169                               margin.toString() : "");
1170         String lightWeightPopupEnabledString = (isLightWeightPopupEnabled() ?
1171                                                 "true" : "false");
1172         return super.paramString() +
1173             ",desiredLocationX=" + desiredLocationX +
1174             ",desiredLocationY=" + desiredLocationY +
1175         ",label=" + labelString +
1176         ",lightWeightPopupEnabled=" + lightWeightPopupEnabledString +
1177         ",margin=" + marginString +
1178         ",paintBorder=" + paintBorderString;
1179     }
1180 
1181 /////////////////
1182 // Accessibility support
1183 ////////////////
1184 
1185     /**
1186      * Gets the AccessibleContext associated with this JPopupMenu.
1187      * For JPopupMenus, the AccessibleContext takes the form of an
1188      * AccessibleJPopupMenu.
1189      * A new AccessibleJPopupMenu instance is created if necessary.
1190      *
1191      * @return an AccessibleJPopupMenu that serves as the
1192      *         AccessibleContext of this JPopupMenu
1193      */
1194     public AccessibleContext getAccessibleContext() {
1195         if (accessibleContext == null) {
1196             accessibleContext = new AccessibleJPopupMenu();
1197         }
1198         return accessibleContext;
1199     }
1200 
1201     /**
1202      * This class implements accessibility support for the
1203      * <code>JPopupMenu</code> class.  It provides an implementation of the
1204      * Java Accessibility API appropriate to popup menu user-interface
1205      * elements.
1206      */
1207     @SuppressWarnings("serial")
1208     protected class AccessibleJPopupMenu extends AccessibleJComponent
1209         implements PropertyChangeListener {
1210 
1211         /**
1212          * AccessibleJPopupMenu constructor
1213          *
1214          * @since 1.5
1215          */
1216         protected AccessibleJPopupMenu() {
1217             JPopupMenu.this.addPropertyChangeListener(this);
1218         }
1219 
1220         /**
1221          * Get the role of this object.
1222          *
1223          * @return an instance of AccessibleRole describing the role of
1224          * the object
1225          */
1226         public AccessibleRole getAccessibleRole() {
1227             return AccessibleRole.POPUP_MENU;
1228         }
1229 
1230         /**
1231          * This method gets called when a bound property is changed.
1232          * @param e A <code>PropertyChangeEvent</code> object describing
1233          * the event source and the property that has changed. Must not be null.
1234          *
1235          * @throws NullPointerException if the parameter is null.
1236          * @since 1.5
1237          */
1238         public void propertyChange(PropertyChangeEvent e) {
1239             String propertyName = e.getPropertyName();
1240             if (propertyName == "visible") {
1241                 if (e.getOldValue() == Boolean.FALSE &&
1242                     e.getNewValue() == Boolean.TRUE) {
1243                     handlePopupIsVisibleEvent(true);
1244 
1245                 } else if (e.getOldValue() == Boolean.TRUE &&
1246                            e.getNewValue() == Boolean.FALSE) {
1247                     handlePopupIsVisibleEvent(false);
1248                 }
1249             }
1250         }
1251 
1252         /*
1253          * Handles popup "visible" PropertyChangeEvent
1254          */
1255         private void handlePopupIsVisibleEvent(boolean visible) {
1256             if (visible) {
1257                 // notify listeners that the popup became visible
1258                 firePropertyChange(ACCESSIBLE_STATE_PROPERTY,
1259                                    null, AccessibleState.VISIBLE);
1260                 // notify listeners that a popup list item is selected
1261                 fireActiveDescendant();
1262             } else {
1263                 // notify listeners that the popup became hidden
1264                 firePropertyChange(ACCESSIBLE_STATE_PROPERTY,
1265                                    AccessibleState.VISIBLE, null);
1266             }
1267         }
1268 
1269         /*
1270          * Fires AccessibleActiveDescendant PropertyChangeEvent to notify listeners
1271          * on the popup menu invoker that a popup list item has been selected
1272          */
1273         private void fireActiveDescendant() {
1274             if (JPopupMenu.this instanceof BasicComboPopup) {
1275                 // get the popup list
1276                 JList<?> popupList = ((BasicComboPopup)JPopupMenu.this).getList();
1277                 if (popupList == null) {
1278                     return;
1279                 }
1280 
1281                 // get the first selected item
1282                 AccessibleContext ac = popupList.getAccessibleContext();
1283                 AccessibleSelection selection = ac.getAccessibleSelection();
1284                 if (selection == null) {
1285                     return;
1286                 }
1287                 Accessible a = selection.getAccessibleSelection(0);
1288                 if (a == null) {
1289                     return;
1290                 }
1291                 AccessibleContext selectedItem = a.getAccessibleContext();
1292 
1293                 // fire the event with the popup invoker as the source.
1294                 if (selectedItem != null && invoker != null) {
1295                     AccessibleContext invokerContext = invoker.getAccessibleContext();
1296                     if (invokerContext != null) {
1297                         // Check invokerContext because Component.getAccessibleContext
1298                         // returns null. Classes that extend Component are responsible
1299                         // for returning a non-null AccessibleContext.
1300                         invokerContext.firePropertyChange(
1301                             ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY,
1302                             null, selectedItem);
1303                     }
1304                 }
1305             }
1306         }
1307     } // inner class AccessibleJPopupMenu
1308 
1309 
1310 ////////////
1311 // Serialization support.
1312 ////////////
1313     private void writeObject(ObjectOutputStream s) throws IOException {
1314         Vector<Object> values = new Vector<Object>();
1315 
1316         s.defaultWriteObject();
1317         // Save the invoker, if its Serializable.
1318         if(invoker != null && invoker instanceof Serializable) {
1319             values.addElement("invoker");
1320             values.addElement(invoker);
1321         }
1322         // Save the popup, if its Serializable.
1323         if(popup != null && popup instanceof Serializable) {
1324             values.addElement("popup");
1325             values.addElement(popup);
1326         }
1327         s.writeObject(values);
1328 
1329         if (getUIClassID().equals(uiClassID)) {
1330             byte count = JComponent.getWriteObjCounter(this);
1331             JComponent.setWriteObjCounter(this, --count);
1332             if (count == 0 && ui != null) {
1333                 ui.installUI(this);
1334             }
1335         }
1336     }
1337 
1338     // implements javax.swing.MenuElement
1339     private void readObject(ObjectInputStream s)
1340         throws IOException, ClassNotFoundException {
1341         s.defaultReadObject();
1342 
1343         Vector<?>          values = (Vector)s.readObject();
1344         int             indexCounter = 0;
1345         int             maxCounter = values.size();
1346 
1347         if(indexCounter < maxCounter && values.elementAt(indexCounter).
1348            equals("invoker")) {
1349             invoker = (Component)values.elementAt(++indexCounter);
1350             indexCounter++;
1351         }
1352         if(indexCounter < maxCounter && values.elementAt(indexCounter).
1353            equals("popup")) {
1354             popup = (Popup)values.elementAt(++indexCounter);
1355             indexCounter++;
1356         }
1357     }
1358 
1359 
1360     /**
1361      * This method is required to conform to the
1362      * <code>MenuElement</code> interface, but it not implemented.
1363      * @see MenuElement#processMouseEvent(MouseEvent, MenuElement[], MenuSelectionManager)
1364      */
1365     public void processMouseEvent(MouseEvent event,MenuElement path[],MenuSelectionManager manager) {}
1366 
1367     /**
1368      * Processes a key event forwarded from the
1369      * <code>MenuSelectionManager</code> and changes the menu selection,
1370      * if necessary, by using <code>MenuSelectionManager</code>'s API.
1371      * <p>
1372      * Note: you do not have to forward the event to sub-components.
1373      * This is done automatically by the <code>MenuSelectionManager</code>.
1374      *
1375      * @param e  a <code>KeyEvent</code>
1376      * @param path the <code>MenuElement</code> path array
1377      * @param manager   the <code>MenuSelectionManager</code>
1378      */
1379     public void processKeyEvent(KeyEvent e, MenuElement path[],
1380                                 MenuSelectionManager manager) {
1381         MenuKeyEvent mke = new MenuKeyEvent(e.getComponent(), e.getID(),
1382                                              e.getWhen(), e.getModifiers(),
1383                                              e.getKeyCode(), e.getKeyChar(),
1384                                              path, manager);
1385         processMenuKeyEvent(mke);
1386 
1387         if (mke.isConsumed())  {
1388             e.consume();
1389     }
1390     }
1391 
1392     /**
1393      * Handles a keystroke in a menu.
1394      *
1395      * @param e  a <code>MenuKeyEvent</code> object
1396      * @since 1.5
1397      */
1398     private void processMenuKeyEvent(MenuKeyEvent e) {
1399         switch (e.getID()) {
1400         case KeyEvent.KEY_PRESSED:
1401             fireMenuKeyPressed(e); break;
1402         case KeyEvent.KEY_RELEASED:
1403             fireMenuKeyReleased(e); break;
1404         case KeyEvent.KEY_TYPED:
1405             fireMenuKeyTyped(e); break;
1406         default:
1407             break;
1408         }
1409     }
1410 
1411     /**
1412      * Notifies all listeners that have registered interest for
1413      * notification on this event type.
1414      *
1415      * @param event a <code>MenuKeyEvent</code>
1416      * @see EventListenerList
1417      */
1418     private void fireMenuKeyPressed(MenuKeyEvent event) {
1419         Object[] listeners = listenerList.getListenerList();
1420         for (int i = listeners.length-2; i>=0; i-=2) {
1421             if (listeners[i]==MenuKeyListener.class) {
1422                 ((MenuKeyListener)listeners[i+1]).menuKeyPressed(event);
1423             }
1424         }
1425     }
1426 
1427     /**
1428      * Notifies all listeners that have registered interest for
1429      * notification on this event type.
1430      *
1431      * @param event a <code>MenuKeyEvent</code>
1432      * @see EventListenerList
1433      */
1434     private void fireMenuKeyReleased(MenuKeyEvent event) {
1435         Object[] listeners = listenerList.getListenerList();
1436         for (int i = listeners.length-2; i>=0; i-=2) {
1437             if (listeners[i]==MenuKeyListener.class) {
1438                 ((MenuKeyListener)listeners[i+1]).menuKeyReleased(event);
1439             }
1440         }
1441     }
1442 
1443     /**
1444      * Notifies all listeners that have registered interest for
1445      * notification on this event type.
1446      *
1447      * @param event a <code>MenuKeyEvent</code>
1448      * @see EventListenerList
1449      */
1450     private void fireMenuKeyTyped(MenuKeyEvent event) {
1451         Object[] listeners = listenerList.getListenerList();
1452         for (int i = listeners.length-2; i>=0; i-=2) {
1453             if (listeners[i]==MenuKeyListener.class) {
1454                 ((MenuKeyListener)listeners[i+1]).menuKeyTyped(event);
1455             }
1456         }
1457     }
1458 
1459     /**
1460      * Messaged when the menubar selection changes to activate or
1461      * deactivate this menu. This implements the
1462      * <code>javax.swing.MenuElement</code> interface.
1463      * Overrides <code>MenuElement.menuSelectionChanged</code>.
1464      *
1465      * @param isIncluded  true if this menu is active, false if
1466      *        it is not
1467      * @see MenuElement#menuSelectionChanged(boolean)
1468      */
1469     public void menuSelectionChanged(boolean isIncluded) {
1470         if (DEBUG) {
1471             System.out.println("In JPopupMenu.menuSelectionChanged " + isIncluded);
1472         }
1473         if(invoker instanceof JMenu) {
1474             JMenu m = (JMenu) invoker;
1475             if(isIncluded)
1476                 m.setPopupMenuVisible(true);
1477             else
1478                 m.setPopupMenuVisible(false);
1479         }
1480         if (isPopupMenu() && !isIncluded)
1481           setVisible(false);
1482     }
1483 
1484     /**
1485      * Returns an array of <code>MenuElement</code>s containing the submenu
1486      * for this menu component.  It will only return items conforming to
1487      * the <code>JMenuElement</code> interface.
1488      * If popup menu is <code>null</code> returns
1489      * an empty array.  This method is required to conform to the
1490      * <code>MenuElement</code> interface.
1491      *
1492      * @return an array of <code>MenuElement</code> objects
1493      * @see MenuElement#getSubElements
1494      */
1495     public MenuElement[] getSubElements() {
1496         MenuElement result[];
1497         Vector<MenuElement> tmp = new Vector<MenuElement>();
1498         int c = getComponentCount();
1499         int i;
1500         Component m;
1501 
1502         for(i=0 ; i < c ; i++) {
1503             m = getComponent(i);
1504             if(m instanceof MenuElement)
1505                 tmp.addElement((MenuElement) m);
1506         }
1507 
1508         result = new MenuElement[tmp.size()];
1509         for(i=0,c=tmp.size() ; i < c ; i++)
1510             result[i] = tmp.elementAt(i);
1511         return result;
1512     }
1513 
1514     /**
1515      * Returns this <code>JPopupMenu</code> component.
1516      * @return this <code>JPopupMenu</code> object
1517      * @see MenuElement#getComponent
1518      */
1519     public Component getComponent() {
1520         return this;
1521     }
1522 
1523 
1524     /**
1525      * A popup menu-specific separator.
1526      */
1527     @SuppressWarnings("serial")
1528     static public class Separator extends JSeparator
1529     {
1530         public Separator( )
1531         {
1532             super( JSeparator.HORIZONTAL );
1533         }
1534 
1535         /**
1536          * Returns the name of the L&F class that renders this component.
1537          *
1538          * @return the string "PopupMenuSeparatorUI"
1539          * @see JComponent#getUIClassID
1540          * @see UIDefaults#getUI
1541          */
1542         public String getUIClassID()
1543         {
1544             return "PopupMenuSeparatorUI";
1545 
1546         }
1547     }
1548 
1549     /**
1550      * Returns true if the <code>MouseEvent</code> is considered a popup trigger
1551      * by the <code>JPopupMenu</code>'s currently installed UI.
1552      *
1553      * @return true if the mouse event is a popup trigger
1554      * @since 1.3
1555      */
1556     public boolean isPopupTrigger(MouseEvent e) {
1557         return getUI().isPopupTrigger(e);
1558     }
1559 }
--- EOF ---