Source for javax.swing.JPopupMenu

   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 gnu.java.lang.CPStringBuilder;
  42: 
  43: import java.awt.Component;
  44: import java.awt.Dimension;
  45: import java.awt.Insets;
  46: import java.awt.Point;
  47: import java.awt.event.KeyEvent;
  48: import java.awt.event.MouseEvent;
  49: import java.beans.PropertyChangeEvent;
  50: import java.beans.PropertyChangeListener;
  51: import java.util.ArrayList;
  52: import java.util.EventListener;
  53: 
  54: import javax.accessibility.Accessible;
  55: import javax.accessibility.AccessibleContext;
  56: import javax.accessibility.AccessibleRole;
  57: import javax.swing.event.MenuKeyListener;
  58: import javax.swing.event.PopupMenuEvent;
  59: import javax.swing.event.PopupMenuListener;
  60: import javax.swing.plaf.PopupMenuUI;
  61: 
  62: /**
  63:  * JPopupMenu is a container that is used to display popup menu's menu
  64:  * items. By default JPopupMenu is a lightweight container, however if it
  65:  * is the case that JPopupMenu's bounds are outside of main window, then
  66:  * heawyweight container will be used to display menu items. It is also
  67:  * possible to change JPopupMenu's default  behavior and set JPopupMenu
  68:  * to always use heavyweight container.
  69:  *
  70:  * JPopupMenu can be displayed anywhere; it is a floating free popup menu.
  71:  * However before JPopupMenu is diplayed, its invoker property should be set.
  72:  * JPopupMenu's invoker is a component relative to which popup menu is
  73:  * displayed.
  74:  *
  75:  * JPopupMenu fires PopupMenuEvents to its registered listeners. Whenever
  76:  * JPopupMenu becomes visible on the screen then PopupMenuEvent indicating
  77:  * that popup menu became visible will be fired. In the case when
  78:  * JPopupMenu becomes invisible or cancelled without selection, then
  79:  * popupMenuBecomeInvisible() or popupMenuCancelled() methods of
  80:  * PopupMenuListeners will be invoked.
  81:  *
  82:  * JPopupMenu also fires PropertyChangeEvents when its bound properties
  83:  * change.In addittion to inheritted bound properties, JPopupMenu has
  84:  * 'visible' bound property. When JPopupMenu becomes visible/invisible on
  85:  * the screen it fires PropertyChangeEvents to its registered
  86:  * PropertyChangeListeners.
  87:  */
  88: public class JPopupMenu extends JComponent implements Accessible, MenuElement
  89: {
  90:   private static final long serialVersionUID = -8336996630009646009L;
  91: 
  92:   /* indicates if popup's menu border should be painted*/
  93:   private boolean borderPainted = true;
  94: 
  95:   /** Flag indicating whether lightweight, mediumweight or heavyweight popup
  96:      is used to display menu items.
  97: 
  98:      These are the possible cases:
  99: 
 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: }