libjava/classpath/javax/swing/JPopupMenu.java

   1 /* JPopupMenu.java --
   2    Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing;
  40
  41 import java.awt.Component;
  42 import java.awt.Dimension;
  43 import java.awt.Insets;
  44 import java.awt.Point;
  45 import java.awt.event.KeyEvent;
  46 import java.awt.event.MouseEvent;
  47 import java.beans.PropertyChangeEvent;
  48 import java.beans.PropertyChangeListener;
  49 import java.util.ArrayList;
  50 import java.util.EventListener;
  51
  52 import javax.accessibility.Accessible;
  53 import javax.accessibility.AccessibleContext;
  54 import javax.accessibility.AccessibleRole;
  55 import javax.swing.event.PopupMenuEvent;
  56 import javax.swing.event.PopupMenuListener;
  57 import javax.swing.plaf.PopupMenuUI;
  58
  59 /**
  60  * JPopupMenu is a container that is used to display popup menu's menu
  61  * items. By default JPopupMenu is a lightweight container, however if it
  62  * is the case that JPopupMenu's bounds are outside of main window, then
  63  * heawyweight container will be used to display menu items. It is also
  64  * possible to change JPopupMenu's default  behavior and set JPopupMenu
  65  * to always use heavyweight container.
  66  *
  67  * JPopupMenu can be displayed anywhere; it is a floating free popup menu.
  68  * However before JPopupMenu is diplayed, its invoker property should be set.
  69  * JPopupMenu's invoker is a component relative to which popup menu is
  70  * displayed.
  71  *
  72  * JPopupMenu fires PopupMenuEvents to its registered listeners. Whenever
  73  * JPopupMenu becomes visible on the screen then PopupMenuEvent indicating
  74  * that popup menu became visible will be fired. In the case when
  75  * JPopupMenu becomes invisible or cancelled without selection, then
  76  * popupMenuBecomeInvisible() or popupMenuCancelled() methods of
  77  * PopupMenuListeners will be invoked.
  78  *
  79  * JPopupMenu also fires PropertyChangeEvents when its bound properties
  80  * change.In addittion to inheritted bound properties, JPopupMenu has
  81  * 'visible' bound property. When JPopupMenu becomes visible/invisible on
  82  * the screen it fires PropertyChangeEvents to its registered
  83  * PropertyChangeListeners.
  84  */
  85 public class JPopupMenu extends JComponent implements Accessible, MenuElement
  86 {
  87   private static final long serialVersionUID = -8336996630009646009L;
  88
  89   /* indicates if popup's menu border should be painted*/
  90   private boolean borderPainted = true;
  91
  92   /** Flag indicating whether lightweight, mediumweight or heavyweight popup
  93      is used to display menu items.
  94
  95      These are the possible cases:
  96
  97      1. if DefaultLightWeightPopupEnabled true
  98          (i)  use lightweight container if popup feets inside top-level window
  99          (ii) only use heavyweight container (JDialog) if popup doesn't fit.
 100
 101      2. if DefaultLightWeightPopupEnabled false
 102          (i) if popup fits, use awt.Panel (mediumWeight)
 103          (ii) if popup doesn't fit, use JDialog (heavyWeight)
 104   */
 105   private static boolean DefaultLightWeightPopupEnabled = true;
 106
 107   /* Component that invokes popup menu. */
 108   transient Component invoker;
 109
 110   /* Label for this popup menu. It is not used in most of the look and feel themes. */
 111   private String label;
 112
 113   /*Amount of space between menuItem's in JPopupMenu and JPopupMenu's border */
 114   private Insets margin;
 115
 116   /** Indicates whether ligthWeight container can be used to display popup
 117      menu. This flag is the same as DefaultLightWeightPopupEnabled, but setting
 118      this flag can change popup menu after creation of the object */
 119   private boolean lightWeightPopupEnabled;
 120
 121   /** SelectionModel that keeps track of menu selection. */
 122   private SingleSelectionModel selectionModel;
 123
 124   /* Popup that is used to display JPopupMenu */
 125   private transient Popup popup;
 126
 127   /**
 128    * Location of the popup, X coordinate.
 129    */
 130   private int popupLocationX;
 131
 132   /**
 133    * Location of the popup, Y coordinate.
 134    */
 135   private int popupLocationY;
 136
 137   /* Field indicating if popup menu is visible or not */
 138   private boolean visible = false;
 139
 140   /**
 141    * Creates a new JPopupMenu object.
 142    */
 143   public JPopupMenu()
 144   {
 145     this(null);
 146   }
 147
 148   /**
 149    * Creates a new JPopupMenu with specified label
 150    *
 151    * @param label Label for popup menu.
 152    */
 153   public JPopupMenu(String label)
 154   {
 155     lightWeightPopupEnabled = getDefaultLightWeightPopupEnabled();
 156     setLabel(label);
 157     setSelectionModel(new DefaultSingleSelectionModel());
 158     super.setVisible(false);
 159     updateUI();
 160   }
 161
 162   /**
 163   * Adds given menu item to the popup menu
 164   *
 165   * @param item menu item to add to the popup menu
 166   *
 167   * @return menu item that was added to the popup menu
 168   */
 169   public JMenuItem add(JMenuItem item)
 170   {
 171     this.insert(item, -1);
 172     return item;
 173   }
 174
 175   /**
 176    * Constructs menu item with a specified label and adds it to
 177    * popup menu
 178    *
 179    * @param text label for the menu item to be added
 180    *
 181    * @return constructed menu item that was added to the popup menu
 182    */
 183   public JMenuItem add(String text)
 184   {
 185     JMenuItem item = new JMenuItem(text);
 186     return add(item);
 187   }
 188
 189   /**
 190    * Constructs menu item associated with the specified action
 191    * and adds it to the popup menu
 192    *
 193    * @param action Action for the new menu item
 194    *
 195    * @return menu item that was added to the menu
 196    */
 197   public JMenuItem add(Action action)
 198   {
 199     JMenuItem item = createActionComponent(action);
 200
 201     if (action != null)
 202       action.addPropertyChangeListener(createActionChangeListener(item));
 203
 204     return add(item);
 205   }
 206
 207   /**
 208    * Revomes component at the given index from the menu.
 209    *
 210    * @param index index of the component that will be removed in the menu
 211    */
 212   public void remove(int index)
 213   {
 214     super.remove(index);
 215     revalidate();
 216   }
 217
 218   /**
 219    * Create menu item associated with the given action
 220    * and inserts it into the popup menu at the specified index
 221    *
 222    * @param action Action for the new menu item
 223    * @param index index in the popup menu at which to insert new menu item.
 224    */
 225   public void insert(Action action, int index)
 226   {
 227     JMenuItem item = new JMenuItem(action);
 228     this.insert(item, index);
 229   }
 230
 231   /**
 232    * Insert given component to the popup menu at the
 233    * specified index
 234    *
 235    * @param component Component to insert
 236    * @param index Index at which to insert given component
 237    */
 238   public void insert(Component component, int index)
 239   {
 240     super.add(component, index);
 241   }
 242
 243   /**
 244    * Returns flag indicating if newly created JPopupMenu will use
 245    * heavyweight or lightweight container to display its menu items
 246    *
 247    * @return true if JPopupMenu will use lightweight container to display
 248    * menu items by default, and false otherwise.
 249    */
 250   public static boolean getDefaultLightWeightPopupEnabled()
 251   {
 252     return DefaultLightWeightPopupEnabled;
 253   }
 254
 255   /**
 256    * Sets whether JPopupMenu should use ligthWeight container to
 257    * display it menu items by default
 258    *
 259    * @param enabled true if JPopupMenu should use lightweight container
 260    * for displaying its menu items, and false otherwise.
 261    */
 262   public static void setDefaultLightWeightPopupEnabled(boolean enabled)
 263   {
 264     DefaultLightWeightPopupEnabled = enabled;
 265   }
 266
 267   /**
 268    * This method returns the UI used to display the JPopupMenu.
 269    *
 270    * @return The UI used to display the JPopupMenu.
 271    */
 272   public PopupMenuUI getUI()
 273   {
 274     return (PopupMenuUI) ui;
 275   }
 276
 277   /**
 278    * Set the "UI" property of the menu item, which is a look and feel class
 279    * responsible for handling popupMenu's input events and painting it.
 280    *
 281    * @param ui The new "UI" property
 282    */
 283   public void setUI(PopupMenuUI ui)
 284   {
 285     super.setUI(ui);
 286   }
 287
 288   /**
 289    * This method sets this menuItem's UI to the UIManager's default for the
 290    * current look and feel.
 291    */
 292   public void updateUI()
 293   {
 294     setUI((PopupMenuUI) UIManager.getUI(this));
 295   }
 296
 297   /**
 298    * This method returns a name to identify which look and feel class will be
 299    * the UI delegate for the menuItem.
 300    *
 301    * @return The Look and Feel classID. "PopupMenuUI"
 302    */
 303   public String getUIClassID()
 304   {
 305     return "PopupMenuUI";
 306   }
 307
 308   /**
 309    * Returns selectionModel used by this popup menu to keep
 310    * track of the selection.
 311    *
 312    * @return popup menu's selection model
 313    */
 314   public SingleSelectionModel getSelectionModel()
 315   {
 316     return selectionModel;
 317   }
 318
 319   /**
 320    * Sets selection model for this popup menu
 321    *
 322    * @param model new selection model of this popup menu
 323    */
 324   public void setSelectionModel(SingleSelectionModel model)
 325   {
 326         selectionModel = model;
 327   }
 328
 329   /**
 330    * Creates new menu item associated with a given action.
 331    *
 332    * @param action Action used to create new menu item
 333    *
 334    * @return new created menu item associated with a given action.
 335    */
 336   protected JMenuItem createActionComponent(Action action)
 337   {
 338     return new JMenuItem(action);
 339   }
 340
 341   /**
 342    * Creates PropertyChangeListener that listens to PropertyChangeEvents
 343    * occuring in the Action associated with given menu item in this popup menu.
 344    *
 345    * @param item MenuItem
 346    *
 347    * @return The PropertyChangeListener
 348    */
 349   protected PropertyChangeListener createActionChangeListener(JMenuItem item)
 350   {
 351     return new ActionChangeListener();
 352   }
 353
 354   /**
 355    * Returns true if this popup menu will display its menu item in
 356    * a lightweight container and false otherwise.
 357    *
 358    * @return true if this popup menu will display its menu items
 359    * in a lightweight container and false otherwise.
 360    */
 361   public boolean isLightWeightPopupEnabled()
 362   {
 363     return lightWeightPopupEnabled;
 364   }
 365
 366   /**
 367    * DOCUMENT ME!
 368    *
 369    * @param enabled DOCUMENT ME!
 370    */
 371   public void setLightWeightPopupEnabled(boolean enabled)
 372   {
 373     lightWeightPopupEnabled = enabled;
 374   }
 375
 376   /**
 377    * Returns label for this popup menu
 378    *
 379    * @return label for this popup menu
 380    */
 381   public String getLabel()
 382   {
 383     return label;
 384   }
 385
 386   /**
 387    * Sets label for this popup menu. This method fires PropertyChangeEvent
 388    * when the label property is changed. Please note that most
 389    * of the Look &amp; Feel will ignore this property.
 390    *
 391    * @param label label for this popup menu
 392    */
 393   public void setLabel(String label)
 394   {
 395     if (label != this.label)
 396       {
 397         String oldLabel = this.label;
 398         this.label = label;
 399         firePropertyChange("label", oldLabel, label);
 400       }
 401   }
 402
 403   /**
 404    * Adds separator to this popup menu
 405    */
 406   public void addSeparator()
 407   {
 408     // insert separator at the end of the list of menu items
 409     this.insert(new Separator(), -1);
 410   }
 411
 412   /**
 413    * Adds popupMenuListener to listen for PopupMenuEvents fired
 414    * by the JPopupMenu
 415    *
 416    * @param listener PopupMenuListener to add to JPopupMenu
 417    */
 418   public void addPopupMenuListener(PopupMenuListener listener)
 419   {
 420     listenerList.add(PopupMenuListener.class, listener);
 421   }
 422
 423   /**
 424    * Removes PopupMenuListener from JPopupMenu's list of listeners
 425    *
 426    * @param listener PopupMenuListener which needs to be removed
 427    */
 428   public void removePopupMenuListener(PopupMenuListener listener)
 429   {
 430     listenerList.remove(PopupMenuListener.class, listener);
 431   }
 432
 433   /**
 434    * Returns array of PopupMenuListeners that are listening to JPopupMenu
 435    *
 436    * @return Array of PopupMenuListeners that are listening to JPopupMenu
 437    */
 438   public PopupMenuListener[] getPopupMenuListeners()
 439   {
 440     return ((PopupMenuListener[]) listenerList.getListeners(PopupMenuListener.class));
 441   }
 442
 443   /**
 444    * This method calls popupMenuWillBecomeVisible() of popup menu's
 445    * PopupMenuListeners. This method is invoked just before popup menu
 446    * will appear on the screen.
 447    */
 448   protected void firePopupMenuWillBecomeVisible()
 449   {
 450     EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
 451
 452     for (int i = 0; i < ll.length; i++)
 453       ((PopupMenuListener) ll[i]).popupMenuWillBecomeVisible(new PopupMenuEvent(this));
 454   }
 455
 456   /**
 457    * This method calls popupMenuWillBecomeInvisible() of popup
 458    * menu's PopupMenuListeners. This method is invoked just before popup
 459    * menu will disappear from the screen
 460    */
 461   protected void firePopupMenuWillBecomeInvisible()
 462   {
 463     EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
 464
 465     for (int i = 0; i < ll.length; i++)
 466       ((PopupMenuListener) ll[i]).popupMenuWillBecomeInvisible(new PopupMenuEvent(this));
 467   }
 468
 469   /**
 470    * This method calls popupMenuCanceled() of popup menu's PopupMenuListeners.
 471    * This method is invoked just before popup menu is cancelled. This happens
 472    * when popup menu is closed without selecting any of its menu items. This
 473    * usually happens when the top-level window is resized or moved.
 474    */
 475   protected void firePopupMenuCanceled()
 476   {
 477     EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
 478
 479     for (int i = 0; i < ll.length; i++)
 480       ((PopupMenuListener) ll[i]).popupMenuCanceled(new PopupMenuEvent(this));
 481   }
 482
 483   /**
 484    * This methods sets popup menu's size to its' preferred size. If the
 485    * popup menu's size is previously set it will be ignored.
 486    */
 487   public void pack()
 488   {
 489     // Hook up this call so that it gets executed on the event thread in order
 490     // to avoid synchronization problems when calling the layout manager.
 491     if (! SwingUtilities.isEventDispatchThread())
 492       {
 493         SwingUtilities.invokeLater(new Runnable()
 494           {
 495             public void run()
 496             {
 497               show();
 498             }
 499           });
 500       }
 501
 502     setSize(getPreferredSize());
 503   }
 504
 505   /**
 506    * Return visibility of the popup menu
 507    *
 508    * @return true if popup menu is visible on the screen and false otherwise.
 509    */
 510   public boolean isVisible()
 511   {
 512     return visible;
 513   }
 514
 515   /**
 516    * Sets visibility property of this popup menu. If the property is
 517    * set to true then popup menu will be dispayed and popup menu will
 518    * hide itself if visible property is set to false.
 519    *
 520    * @param visible true if popup menu will become visible and false otherwise.
 521    */
 522   public void setVisible(final boolean visible)
 523   {
 524     // Hook up this call so that it gets executed on the event thread in order
 525     // to avoid synchronization problems when calling the layout manager.
 526     if (! SwingUtilities.isEventDispatchThread())
 527       {
 528         SwingUtilities.invokeLater(new Runnable()
 529           {
 530             public void run()
 531             {
 532               setVisible(visible);
 533             }
 534           });
 535       }
 536
 537     if (visible == isVisible())
 538       return;
 539
 540     boolean old = isVisible();
 541     this.visible = visible;
 542     if (old != isVisible())
 543       {
 544         if (visible)
 545           {
 546             if (invoker != null && !(invoker instanceof JMenu))
 547               {
 548                 MenuElement[] menuEls;
 549                 if (getSubElements().length > 0)
 550                   {
 551                     menuEls = new MenuElement[2];
 552                     menuEls[0] = this;
 553                     menuEls[1] = getSubElements()[0];
 554                 }
 555                 else
 556                   {
 557                     menuEls = new MenuElement[1];
 558                     menuEls[0] = this;
 559                   }
 560                 MenuSelectionManager.defaultManager().setSelectedPath(menuEls);
 561               }
 562             firePopupMenuWillBecomeVisible();
 563             PopupFactory pf = PopupFactory.getSharedInstance();
 564             pack();
 565             popup = pf.getPopup(invoker, this, popupLocationX, popupLocationY);
 566             popup.show();
 567           }
 568         else
 569           {
 570             getSelectionModel().clearSelection();
 571             firePopupMenuWillBecomeInvisible();
 572             popup.hide();
 573           }
 574         firePropertyChange("visible", old, isVisible());
 575       }
 576   }
 577
 578   /**
 579    * Sets location of the popup menu.
 580    *
 581    * @param x X coordinate of the popup menu's location
 582    * @param y Y coordinate of the popup menu's location
 583    */
 584   public void setLocation(int x, int y)
 585   {
 586     popupLocationX = x;
 587     popupLocationY = y;
 588     // Handle the case when the popup is already showing. In this case we need
 589     // to fetch a new popup from PopupFactory and use this. See the general
 590     // contract of the PopupFactory.
 591   }
 592
 593   /**
 594    * Returns popup menu's invoker.
 595    *
 596    * @return popup menu's invoker
 597    */
 598   public Component getInvoker()
 599   {
 600     return invoker;
 601   }
 602
 603   /**
 604    * Sets popup menu's invoker.
 605    *
 606    * @param component The new invoker of this popup menu
 607    */
 608   public void setInvoker(Component component)
 609   {
 610     invoker = component;
 611   }
 612
 613   /**
 614    * This method displays JPopupMenu on the screen at the specified
 615    * location. Note that x and y coordinates given to this method
 616    * should be expressed in terms of the popup menus' invoker.
 617    *
 618    * @param component Invoker for this popup menu
 619    * @param x x-coordinate of the popup menu relative to the specified invoker
 620    * @param y y-coordiate of the popup menu relative to the specified invoker
 621    */
 622   public void show(Component component, int x, int y)
 623   {
 624     if (component.isShowing())
 625       {
 626         setInvoker(component);
 627         Point p = new Point(x, y);
 628         SwingUtilities.convertPointToScreen(p, component);
 629         setLocation(p.x, p.y);
 630         setVisible(true);
 631       }
 632   }
 633
 634   /**
 635    * Returns component located at the specified index in the popup menu
 636    *
 637    * @param index index of the component to return
 638    *
 639    * @return component located at the specified index in the popup menu
 640    *
 641    * @deprecated Replaced by getComponent(int)
 642    */
 643   public Component getComponentAtIndex(int index)
 644   {
 645     return getComponent(index);
 646   }
 647
 648   /**
 649    * Returns index of the specified component in the popup menu
 650    *
 651    * @param component Component to look for
 652    *
 653    * @return index of the specified component in the popup menu
 654    */
 655   public int getComponentIndex(Component component)
 656   {
 657     Component[] items = getComponents();
 658
 659     for (int i = 0; i < items.length; i++)
 660       {
 661         if (items[i].equals(component))
 662           return i;
 663       }
 664
 665     return -1;
 666   }
 667
 668   /**
 669    * Sets size of the popup
 670    *
 671    * @param size Dimensions representing new size of the popup menu
 672    */
 673   public void setPopupSize(Dimension size)
 674   {
 675     super.setSize(size);
 676   }
 677
 678   /**
 679    * Sets size of the popup menu
 680    *
 681    * @param width width for the new size
 682    * @param height height for the new size
 683    */
 684   public void setPopupSize(int width, int height)
 685   {
 686     super.setSize(width, height);
 687   }
 688
 689   /**
 690    * Selects specified component in this popup menu.
 691    *
 692    * @param selected component to select
 693    */
 694   public void setSelected(Component selected)
 695   {
 696     int index = getComponentIndex(selected);
 697     selectionModel.setSelectedIndex(index);
 698   }
 699
 700   /**
 701    * Checks if this popup menu paints its border.
 702    *
 703    * @return true if this popup menu paints its border and false otherwise.
 704    */
 705   public boolean isBorderPainted()
 706   {
 707     return borderPainted;
 708   }
 709
 710   /**
 711    * Sets if the border of the popup menu should be
 712    * painter or not.
 713    *
 714    * @param painted true if the border should be painted and false otherwise
 715    */
 716   public void setBorderPainted(boolean painted)
 717   {
 718     borderPainted = painted;
 719   }
 720
 721   /**
 722    * Returns margin for this popup menu.
 723    *
 724    * @return margin for this popup menu.
 725    */
 726   public Insets getMargin()
 727   {
 728     return margin;
 729   }
 730
 731   /**
 732    * A string that describes this JPopupMenu. Normally only used
 733    * for debugging.
 734    *
 735    * @return A string describing this JMenuItem
 736    */
 737   protected String paramString()
 738   {
 739     StringBuffer sb = new StringBuffer();
 740     sb.append(super.paramString());
 741     sb.append(",label=");
 742     if (getLabel() != null)
 743       sb.append(getLabel());
 744     sb.append(",lightWeightPopupEnabled=").append(isLightWeightPopupEnabled());
 745     sb.append(",margin=");
 746     if (getMargin() != null)
 747       sb.append(margin);
 748     sb.append(",paintBorder=").append(isBorderPainted());
 749     return sb.toString();
 750   }
 751
 752   /**
 753   * Process mouse events forwarded from MenuSelectionManager. This method
 754   * doesn't do anything. It is here to conform to the MenuElement interface.
 755   *
 756   * @param event event forwarded from MenuSelectionManager
 757   * @param path path to the menu element from which event was generated
 758   * @param manager MenuSelectionManager for the current menu hierarchy
 759   */
 760   public void processMouseEvent(MouseEvent event, MenuElement[] path,
 761                                 MenuSelectionManager manager)
 762   {
 763     // Empty Implementation. This method is needed for the implementation
 764     // of MenuElement interface
 765   }
 766
 767   /**
 768    * Process key events forwarded from MenuSelectionManager. This method
 769    * doesn't do anything. It is here to conform to the MenuElement interface.
 770    *
 771    * @param event event forwarded from MenuSelectionManager
 772    * @param path path to the menu element from which event was generated
 773    * @param manager MenuSelectionManager for the current menu hierarchy
 774    *
 775    */
 776   public void processKeyEvent(KeyEvent event, MenuElement[] path,
 777                               MenuSelectionManager manager)
 778   {
 779     // Empty Implementation. This method is needed for the implementation
 780     // of MenuElement interface
 781   }
 782
 783   /**
 784    * Method of MenuElement Interface. It is invoked when
 785    * popupMenu's selection has changed
 786    *
 787    * @param changed true if this popupMenu is part of current menu
 788    * hierarchy and false otherwise.
 789    */
 790   public void menuSelectionChanged(boolean changed)
 791   {
 792     if (! changed)
 793       setVisible(false);
 794   }
 795
 796   /**
 797    * Return subcomonents of this popup menu. This method returns only
 798    * components that implement the <code>MenuElement</code> interface.
 799    *
 800    * @return array of menu items belonging to this popup menu
 801    */
 802   public MenuElement[] getSubElements()
 803   {
 804     Component[] items = getComponents();
 805     ArrayList subElements = new ArrayList();
 806
 807     for (int i = 0; i < items.length; i++)
 808       if (items[i] instanceof MenuElement)
 809         subElements.add(items[i]);
 810
 811     return (MenuElement[])
 812       subElements.toArray(new MenuElement[subElements.size()]);
 813   }
 814
 815   /**
 816    * Method of the MenuElement interface. Returns reference to itself.
 817    *
 818    * @return Returns reference to itself
 819    */
 820   public Component getComponent()
 821   {
 822     return this;
 823   }
 824
 825   /**
 826    * Checks if observing mouse event should trigger popup
 827    * menu to show on the screen.
 828    *
 829    * @param event MouseEvent to check
 830    *
 831    * @return true if the observing mouse event is popup trigger and false otherwise
 832    */
 833   public boolean isPopupTrigger(MouseEvent event)
 834   {
 835     return ((PopupMenuUI) getUI()).isPopupTrigger(event);
 836   }
 837
 838   /**
 839    * DOCUMENT ME!
 840    *
 841    * @return DOCUMENT ME!
 842    */
 843   public AccessibleContext getAccessibleContext()
 844   {
 845     if (accessibleContext == null)
 846       accessibleContext = new AccessibleJPopupMenu();
 847
 848     return accessibleContext;
 849   }
 850
 851   /**
 852    * This is the separator that can be used in popup menu.
 853    */
 854   public static class Separator extends JSeparator
 855   {
 856     public Separator()
 857     {
 858       super();
 859     }
 860
 861     public String getUIClassID()
 862     {
 863       return "PopupMenuSeparatorUI";
 864     }
 865   }
 866
 867   protected class AccessibleJPopupMenu extends AccessibleJComponent
 868   {
 869     private static final long serialVersionUID = 7423261328879849768L;
 870
 871     protected AccessibleJPopupMenu()
 872     {
 873       // Nothing to do here.
 874     }
 875
 876     public AccessibleRole getAccessibleRole()
 877     {
 878       return AccessibleRole.POPUP_MENU;
 879     }
 880   }
 881
 882   /* This class resizes popup menu and repaints popup menu appropriately if one
 883    of item's action has changed */
 884   private class ActionChangeListener implements PropertyChangeListener
 885   {
 886     public void propertyChange(PropertyChangeEvent evt)
 887     {
 888       // We used to have a revalidate() and repaint() call here. However I think
 889       // this is not needed. Instead, a new Popup has to be fetched from the
 890       // PopupFactory and used here.
 891     }
 892   }
 893 }