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