1 /* MenuComponent.java -- Superclass of all AWT menu components 2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006 3 Free Software Foundation, Inc. 4 5 This file is part of GNU Classpath. 6 7 GNU Classpath is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GNU Classpath is distributed in the hope that it will be useful, but 13 WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GNU Classpath; see the file COPYING. If not, write to the 19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20 02110-1301 USA. 21 22 Linking this library statically or dynamically with other modules is 23 making a combined work based on this library. Thus, the terms and 24 conditions of the GNU General Public License cover the whole 25 combination. 26 27 As a special exception, the copyright holders of this library give you 28 permission to link this library with independent modules to produce an 29 executable, regardless of the license terms of these independent 30 modules, and to copy and distribute the resulting executable under 31 terms of your choice, provided that you also meet, for each linked 32 independent module, the terms and conditions of the license of that 33 module. An independent module is a module which is not derived from 34 or based on this library. If you modify this library, you may extend 35 this exception to your version of the library, but you are not 36 obligated to do so. If you do not wish to do so, delete this 37 exception statement from your version. */ 38 39 40 package java.awt; 41 42 import java.awt.event.FocusEvent; 43 import java.awt.event.FocusListener; 44 import java.awt.peer.MenuComponentPeer; 45 import java.io.Serializable; 46 import java.util.Locale; 47 48 import javax.accessibility.Accessible; 49 import javax.accessibility.AccessibleComponent; 50 import javax.accessibility.AccessibleContext; 51 import javax.accessibility.AccessibleRole; 52 import javax.accessibility.AccessibleSelection; 53 import javax.accessibility.AccessibleStateSet; 54 55 /** 56 * This is the superclass of all menu AWT widgets. 57 * 58 * @author Aaron M. Renn (arenn@urbanophile.com) 59 * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 60 */ 61 public abstract class MenuComponent implements Serializable 62 { 63 64 //Serialization Constant 65 private static final long serialVersionUID = -4536902356223894379L; 66 67 /** 68 * The font for this component. 69 * 70 * @see #getFont() 71 * @see #setFont(java.awt.Font) 72 * @serial the component's font. 73 */ 74 private Font font; 75 76 /** 77 * The name of the component. 78 * 79 * @see #getName() 80 * @see #setName(String) 81 * @serial the component's name. 82 */ 83 private String name; 84 85 /** 86 * The parent of this component. 87 * 88 * @see #getParent() 89 * @see #setParent(java.awt.MenuContainer) 90 * @serial ignored. 91 */ 92 transient MenuContainer parent; 93 94 /** 95 * The native peer for this component. 96 * 97 * @see #getPeer() 98 * @see #setPeer(java.awt.peer.MenuComponentPeer) 99 * @serial ignored. 100 */ 101 transient MenuComponentPeer peer; 102 103 /** 104 * The synchronization locking object for this component. 105 * 106 * @serial ignored. 107 */ 108 private transient Object tree_lock = this; 109 110 /** 111 * The toolkit for this object. 112 * 113 * @see #getToolkit() 114 * @serial ignored. 115 */ 116 private static transient Toolkit toolkit = Toolkit.getDefaultToolkit(); 117 118 /** 119 * The accessible context for this component. 120 * 121 * @see #getAccessibleContext() 122 * @serial the accessibility information for this component. 123 */ 124 AccessibleContext accessibleContext; 125 126 /** 127 * Was the name of the component set? This value defaults 128 * to false and becomes true after a call to <code>setName()</code>. 129 * Please note that this does not guarantee that name will then 130 * be non-null, as this may be the value passed to <code>setName()</code>. 131 * 132 * @see #setName(String) 133 * @serial true if the name value has been explicitly set by calling 134 * <code>setName()</code>. 135 */ 136 private boolean nameExplicitlySet; 137 138 /** 139 * Does this component handle new events? Events will be handled 140 * by this component if this is true. Otherwise, they will be forwarded 141 * up the component hierarchy. This implementation does not use this 142 * variable; it is merely provided for serialization compatability. 143 * 144 * @see #dispatchEvent(AWTEvent) 145 * @serial true if events are to be processed locally. Unused. 146 */ 147 private boolean newEventsOnly; 148 149 /** 150 * The focus listener chain handler which deals with focus events for 151 * the accessible context of this component. 152 * 153 * @see AccessibleAWTMenuComponent#addFocusListener(java.awt.event.FocusListener) 154 * @serial ignored. 155 * This is package-private to avoid an accessor method. 156 */ 157 transient FocusListener focusListener; 158 159 /** 160 * Default constructor for subclasses. 161 * 162 * @throws HeadlessException ff GraphicsEnvironment.isHeadless() is true 163 */ MenuComponent()164 public MenuComponent() 165 { 166 if (GraphicsEnvironment.isHeadless()) 167 throw new HeadlessException(); 168 } 169 170 /** 171 * Returns the font in use for this component. 172 * 173 * @return the font for this component 174 */ getFont()175 public Font getFont() 176 { 177 if (font != null) 178 return font; 179 180 if (parent != null) 181 return parent.getFont(); 182 183 return null; 184 } 185 186 /** 187 * Sets the font for this component to the specified font. 188 * 189 * @param font the new font for this component 190 */ setFont(Font font)191 public void setFont(Font font) 192 { 193 this.font = font; 194 } 195 196 /** 197 * Returns the name of this component. 198 * 199 * @return the name of this component 200 */ getName()201 public String getName() 202 { 203 if (name == null && ! nameExplicitlySet) 204 name = generateName(); 205 return name; 206 } 207 208 /** 209 * Subclasses should override this to return unique component names like 210 * "menuitem0". 211 * 212 * @return the generated name for this menu component 213 */ generateName()214 String generateName() 215 { 216 // MenuComponent is abstract. 217 return null; 218 } 219 220 /** 221 * Sets the name of this component to the specified name. 222 * 223 * @param name the new name of this component 224 */ setName(String name)225 public void setName(String name) 226 { 227 this.name = name; 228 nameExplicitlySet = true; 229 } 230 231 /** 232 * Returns the parent of this component. 233 * 234 * @return the parent of this component 235 */ getParent()236 public MenuContainer getParent() 237 { 238 return parent; 239 } 240 241 /** 242 * Sets the parent of this component. 243 * 244 * @param parent the parent to set 245 */ setParent(MenuContainer parent)246 final void setParent(MenuContainer parent) 247 { 248 this.parent = parent; 249 } 250 251 /** 252 * Returns the native windowing system peer for this component. 253 * 254 * @return the peer for this component 255 * 256 * @deprecated 257 */ getPeer()258 public MenuComponentPeer getPeer() 259 { 260 return peer; 261 } 262 263 /** 264 * Sets the peer for this component. 265 * 266 * @param peer the peer to set 267 */ setPeer(MenuComponentPeer peer)268 final void setPeer(MenuComponentPeer peer) 269 { 270 this.peer = peer; 271 } 272 273 /** 274 * Destroys this component's native peer 275 */ removeNotify()276 public void removeNotify() 277 { 278 if (peer != null) 279 peer.dispose(); 280 peer = null; 281 } 282 283 /** 284 * Returns the toolkit in use for this component. 285 * 286 * @return the toolkit for this component 287 */ getToolkit()288 final Toolkit getToolkit() 289 { 290 return toolkit; 291 } 292 293 /** 294 * Returns the object used for synchronization locks on this component 295 * when performing tree and layout functions. 296 * 297 * @return the synchronization lock for this component 298 */ getTreeLock()299 protected final Object getTreeLock() 300 { 301 return tree_lock; 302 } 303 304 /** 305 * Sets the sync lock object for this component. 306 * 307 * @param treeLock the sync lock to set 308 */ setTreeLock(Object treeLock)309 final void setTreeLock(Object treeLock) 310 { 311 this.tree_lock = treeLock; 312 } 313 314 /** 315 * AWT 1.0 event dispatcher. 316 * 317 * @return true if the event was dispatched, false otherwise 318 * 319 * @deprecated Deprecated in favor of <code>dispatchEvent()</code>. 320 */ 321 public boolean postEvent(Event event)322 postEvent(Event event) 323 { 324 boolean retVal = false; 325 MenuContainer parent = getParent(); 326 if (parent != null) 327 retVal = parent.postEvent(event); 328 329 return retVal; 330 } 331 332 /** 333 * Sends this event to this component or a subcomponent for processing. 334 * 335 * @param event The event to dispatch 336 */ dispatchEvent(AWTEvent event)337 public final void dispatchEvent(AWTEvent event) 338 { 339 // Convert AWT 1.1 event to AWT 1.0 event. 340 Event oldStyleEvent = Component.translateEvent(event); 341 if (oldStyleEvent != null) 342 { 343 postEvent(oldStyleEvent); 344 } 345 346 // See comment in Component.dispatchEvent(). 347 dispatchEventImpl(event); 348 } 349 350 /** 351 * Implementation of dispatchEvent. Allows trusted package classes 352 * to dispatch additional events first. This implementation first 353 * translates <code>event</code> to an AWT 1.0 event and sends the 354 * result to {@link #postEvent}. The event is then 355 * passed on to {@link #processEvent} for local processing. 356 * 357 * @param event the event to dispatch 358 */ dispatchEventImpl(AWTEvent event)359 void dispatchEventImpl(AWTEvent event) 360 { 361 // Do local processing. 362 processEvent(event); 363 } 364 365 /** 366 * Processes the specified event. In this class, this method simply 367 * calls one of the more specific event handlers. 368 * 369 * @param event the event to process 370 */ processEvent(AWTEvent event)371 protected void processEvent(AWTEvent event) 372 { 373 // Pass a focus event to the focus listener for 374 // the accessibility context. 375 if (event instanceof FocusEvent) 376 { 377 if (focusListener != null) 378 { 379 switch (event.id) 380 { 381 case FocusEvent.FOCUS_GAINED: 382 focusListener.focusGained((FocusEvent) event); 383 break; 384 case FocusEvent.FOCUS_LOST: 385 focusListener.focusLost((FocusEvent) event); 386 break; 387 } 388 } 389 } 390 } 391 392 /** 393 * Returns a string representation of this component. 394 * 395 * @return a string representation of this component 396 */ toString()397 public String toString() 398 { 399 return getClass().getName() + "[" + paramString() + "]"; 400 } 401 402 /** 403 * Returns a debugging string for this component 404 */ paramString()405 protected String paramString() 406 { 407 return "name=" + getName(); 408 } 409 410 /** 411 * Gets the AccessibleContext associated with this <code>MenuComponent</code>. 412 * As an abstract class, we return null. Concrete subclasses should return 413 * their implementation of the accessibility context. 414 * 415 * @return null 416 */ getAccessibleContext()417 public AccessibleContext getAccessibleContext() 418 { 419 return null; 420 } 421 422 /** 423 * This class provides a base for the accessibility support of menu 424 * components. 425 * 426 * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 427 */ 428 protected abstract class AccessibleAWTMenuComponent 429 extends AccessibleContext 430 implements Serializable, AccessibleComponent, AccessibleSelection 431 { 432 433 /** 434 * Compatible with JDK 1.4.2 revision 5 435 */ 436 private static final long serialVersionUID = -4269533416223798698L; 437 438 /** 439 * This is the default constructor. It should be called by 440 * concrete subclasses to ensure necessary groundwork is completed. 441 */ AccessibleAWTMenuComponent()442 protected AccessibleAWTMenuComponent() 443 { 444 // Nothing to do here. 445 } 446 447 /** 448 * Replaces or supplements the component's selection with the 449 * <code>Accessible</code> child at the supplied index. If 450 * the component supports multiple selection, the child is 451 * added to the current selection. Otherwise, the current 452 * selection becomes the specified child. If the child is 453 * already selected, nothing happens. 454 * <br /> 455 * <br /> 456 * As the existence of children can not be determined from 457 * this abstract class, the implementation of this method 458 * is left to subclasses. 459 * 460 * @param index the index of the specified child within a 461 * zero-based list of the component's children 462 */ addAccessibleSelection(int index)463 public void addAccessibleSelection(int index) 464 { 465 // Subclasses with children should implement this. 466 } 467 468 /** 469 * Registers the specified focus listener to receive 470 * focus events from this component. 471 * 472 * @param listener the new focus listener 473 */ addFocusListener(FocusListener listener)474 public void addFocusListener(FocusListener listener) 475 { 476 // Chain the new focus listener to the existing chain 477 // of focus listeners. Each new focus listener is 478 // coupled via multicasting to the existing chain. 479 focusListener = AWTEventMulticaster.add(focusListener, listener); 480 } 481 482 /** 483 * Clears the component's current selection. Following 484 * the calling of this method, no children of the component 485 * will be selected. 486 * <br /> 487 * <br /> 488 * As the existence of children can not be determined from 489 * this abstract class, the implementation of this method 490 * is left to subclasses. 491 */ clearAccessibleSelection()492 public void clearAccessibleSelection() 493 { 494 // Nothing to do here. 495 } 496 497 /** 498 * Returns true if the specified point lies within the 499 * component. The supplied co-ordinates are assumed to 500 * be relative to the co-ordinate system of the component 501 * itself. Thus, the point (0,0) is the upper left corner 502 * of this component. 503 * <br /> 504 * <br /> 505 * Please note that this method depends on a correctly implemented 506 * version of the <code>getBounds()</code> method. Subclasses 507 * must provide the bounding rectangle via <code>getBounds()</code> 508 * in order for this method to work. 509 * 510 * @param point the point to check against this component 511 * @return true if the point is within this component 512 * @see #getBounds() 513 */ contains(Point point)514 public boolean contains(Point point) 515 { 516 // We can simply return the result of a 517 // test for containment in the bounding rectangle. 518 return getBounds().contains(point); 519 } 520 521 /** 522 * Returns the <code>Accessible</code> child of this component present 523 * at the specified point. The supplied co-ordinates are 524 * assumed to be relative to the co-ordinate system of this 525 * component (the parent of any returned accessible). Thus, 526 * the point (0,0) is the upper left corner of this menu 527 * component. 528 * <br /> 529 * <br /> 530 * As the existence of children can not be determined from 531 * this abstract class, the implementation of this method 532 * is left to subclasses. 533 * 534 * @param point the point at which the returned accessible 535 * is located 536 * @return null 537 */ getAccessibleAt(Point point)538 public Accessible getAccessibleAt(Point point) 539 { 540 return null; 541 } 542 543 /** 544 * Returns the <code>Accessible</code> child at the supplied 545 * index within the list of children of this component. 546 * <br /> 547 * <br /> 548 * As the existence of children can not be determined from 549 * this abstract class, the implementation of this method 550 * is left to subclasses. 551 * 552 * @param index the index of the <code>Accessible</code> child 553 * to retrieve 554 * 555 * @return null 556 */ getAccessibleChild(int index)557 public Accessible getAccessibleChild(int index) 558 { 559 return null; 560 } 561 562 /** 563 * Returns the number of children of this component which 564 * implement the <code>Accessible</code> interface. If 565 * all children of this component are accessible, then 566 * the returned value will be the same as the number of 567 * children. 568 * <br /> 569 * <br /> 570 * 571 * @return 0 572 */ getAccessibleChildrenCount()573 public int getAccessibleChildrenCount() 574 { 575 return 0; 576 } 577 578 /** 579 * Retrieves the <code>AccessibleComponent</code> associated 580 * with this accessible context and its component. As the 581 * context itself implements <code>AccessibleComponent</code>, 582 * this is the return value. 583 * 584 * @return the context itself 585 */ getAccessibleComponent()586 public AccessibleComponent getAccessibleComponent() 587 { 588 return this; 589 } 590 591 /** 592 * Returns the accessible name for this menu component. This 593 * is the name given to the component, which may be null if 594 * not set using <code>setName()</code>. 595 * <br /> 596 * <br /> 597 * The name is not the most appropriate description of this 598 * object. Subclasses should preferably provide a more 599 * accurate description. For example, a File menu could 600 * have the description `Lists commands related to the 601 * file system'. 602 * 603 * @return a description of the component. Currently, 604 * this is just the contents of the name property 605 * 606 * @see MenuComponent#setName(String) 607 */ getAccessibleDescription()608 public String getAccessibleDescription() 609 { 610 return MenuComponent.this.getName(); 611 } 612 613 /** 614 * Retrieves the index of this component within its parent. 615 * If no parent exists, -1 is returned. 616 * 617 * @return -1 as the parent, a <code>MenuContainer</code> 618 * is not <code>Accessible</code> 619 */ getAccessibleIndexInParent()620 public int getAccessibleIndexInParent() 621 { 622 return -1; 623 } 624 625 /** 626 * Returns the accessible name of this component. This 627 * is the name given to the component, which may be null if 628 * not set using <code>setName()</code>. 629 * <br /> 630 * <br /> 631 * The name property is not the most suitable string to return 632 * for this method. The string should be localized, and 633 * relevant to the operation of the component. For example, 634 * it could be the text of a menu item. However, this can 635 * not be used at this level of abstraction, so it is the 636 * responsibility of subclasses to provide a more appropriate 637 * name. 638 * 639 * @return a localized name for this component. Currently, this 640 * is just the contents of the name property 641 * 642 * @see MenuComponent#setName(String) 643 */ getAccessibleName()644 public String getAccessibleName() 645 { 646 return MenuComponent.this.getName(); 647 } 648 649 /** 650 * Returns the <code>Accessible</code> parent of this component. 651 * As the parent of a <code>MenuComponent</code> is a 652 * <code>MenuContainer</code>, which doesn't implement 653 * <code>Accessible</code>, this method returns null. 654 * 655 * @return null 656 */ getAccessibleParent()657 public Accessible getAccessibleParent() 658 { 659 return null; 660 } 661 662 /** 663 * Returns the accessible role of this component. 664 * <br /> 665 * <br /> 666 * The abstract implementation of this method returns 667 * <code>AccessibleRole.AWT_COMPONENT</code>, 668 * as the abstract component has no specific role. This 669 * method should be overridden by concrete subclasses, so 670 * as to return an appropriate role for the component. 671 * 672 * @return <code>AccessibleRole.AWT_COMPONENT</code> 673 */ getAccessibleRole()674 public AccessibleRole getAccessibleRole() 675 { 676 return AccessibleRole.AWT_COMPONENT; 677 } 678 679 /** 680 * Retrieves the <code>AccessibleSelection</code> associated 681 * with this accessible context and its component. As the 682 * context itself implements <code>AccessibleSelection</code>, 683 * this is the return value. 684 * 685 * @return the context itself 686 */ getAccessibleSelection()687 public AccessibleSelection getAccessibleSelection() 688 { 689 return this; 690 } 691 692 /** 693 * Retrieves the <code>Accessible</code> selected child 694 * at the specified index. If there are no selected children 695 * or the index is outside the range of selected children, 696 * null is returned. Please note that the index refers 697 * to the index of the child in the list of <strong>selected 698 * children</strong>, and not the index of the child in 699 * the list of all <code>Accessible</code> children. 700 * <br /> 701 * <br /> 702 * As the existence of children can not be determined from 703 * this abstract class, the implementation of this method 704 * is left to subclasses. 705 * 706 * @param index the index of the selected <code>Accessible</code> 707 * child 708 */ getAccessibleSelection(int index)709 public Accessible getAccessibleSelection(int index) 710 { 711 return null; 712 } 713 714 /** 715 * Returns a count of the number of <code>Accessible</code> 716 * children of this component which are currently selected. 717 * If there are no children currently selected, 0 is returned. 718 * <br /> 719 * <br /> 720 * As the existence of children can not be determined from 721 * this abstract class, the implementation of this method 722 * is left to subclasses. 723 * 724 * @return 0 725 */ getAccessibleSelectionCount()726 public int getAccessibleSelectionCount() 727 { 728 return 0; 729 } 730 731 /** 732 * Retrieves the current state of this component 733 * in an accessible form. For example, a given component 734 * may be visible, selected, disabled, etc. 735 * <br /> 736 * <br /> 737 * As this class tells us virtually nothing about the component, 738 * except for its name and font, no state information can be 739 * provided. This implementation thus returns an empty 740 * state set, and it is left to concrete subclasses to provide 741 * a more acceptable and relevant state set. Changes to these 742 * properties also need to be handled using 743 * <code>PropertyChangeListener</code>s. 744 * 745 * @return an empty <code>AccessibleStateSet</code> 746 */ getAccessibleStateSet()747 public AccessibleStateSet getAccessibleStateSet() 748 { 749 return new AccessibleStateSet(); 750 } 751 752 /** 753 * Returns the background color of the component, or null 754 * if this property is unsupported. 755 * <br /> 756 * <br /> 757 * This abstract class knows nothing about how the component 758 * is drawn on screen, so this method simply returns the 759 * default system background color used for rendering menus. 760 * Concrete subclasses which handle the drawing of an onscreen 761 * menu component should override this method and provide 762 * the appropriate information. 763 * 764 * @return the default system background color for menus 765 * 766 * @see #setBackground(java.awt.Color) 767 */ getBackground()768 public Color getBackground() 769 { 770 return SystemColor.menu; 771 } 772 773 /** 774 * Returns a <code>Rectangle</code> which represents the 775 * bounds of this component. The returned rectangle has the 776 * height and width of the component's bounds, and is positioned 777 * at a location relative to this component's parent, the 778 * <code>MenuContainer</code>. null is returned if bounds 779 * are not supported by the component. 780 * <br /> 781 * <br /> 782 * This abstract class knows nothing about how the component 783 * is drawn on screen, so this method simply returns null. 784 * Concrete subclasses which handle the drawing of an onscreen 785 * menu component should override this method and provide 786 * the appropriate information. 787 * 788 * @return null 789 * 790 * @see #setBounds(java.awt.Rectangle) 791 */ getBounds()792 public Rectangle getBounds() 793 { 794 return null; 795 } 796 797 /** 798 * Returns the <code>Cursor</code> displayed when the pointer 799 * is positioned over this component. Alternatively, null 800 * is returned if the component doesn't support the cursor 801 * property. 802 * <br /> 803 * <br /> 804 * This abstract class knows nothing about how the component 805 * is drawn on screen, so this method simply returns the default 806 * system cursor. Concrete subclasses which handle the drawing 807 * of an onscreen menu component may override this method and provide 808 * the appropriate information. 809 * 810 * @return the default system cursor 811 * 812 * @see #setCursor(java.awt.Cursor) 813 */ getCursor()814 public Cursor getCursor() 815 { 816 return Cursor.getDefaultCursor(); 817 } 818 819 /** 820 * Returns the <code>Font</code> used for text created by this component. 821 * 822 * @return the current font 823 * 824 * @see #setFont(java.awt.Font) 825 */ getFont()826 public Font getFont() 827 { 828 return MenuComponent.this.getFont(); 829 } 830 831 /** 832 * Retrieves information on the rendering and metrics of the supplied 833 * font. If font metrics are not supported by this component, null 834 * is returned. 835 * <br /> 836 * <br /> 837 * The abstract implementation of this method simply uses the toolkit 838 * to obtain the <code>FontMetrics</code>. Concrete subclasses may 839 * find it more efficient to invoke their peer class directly, if one 840 * is available. 841 * 842 * @param font the font about which to retrieve rendering and metric 843 * information 844 * 845 * @return the metrics of the given font, as provided by the system 846 * toolkit 847 * 848 * @throws NullPointerException if the supplied font was null 849 */ getFontMetrics(Font font)850 public FontMetrics getFontMetrics(Font font) 851 { 852 return MenuComponent.this.getToolkit().getFontMetrics(font); 853 } 854 855 /** 856 * Returns the foreground color of the component, or null 857 * if this property is unsupported. 858 * <br /> 859 * <br /> 860 * This abstract class knows nothing about how the component 861 * is drawn on screen, so this method simply returns the 862 * default system text color used for rendering menus. 863 * Concrete subclasses which handle the drawing of an onscreen 864 * menu component should override this method and provide 865 * the appropriate information. 866 * 867 * @return the default system text color for menus 868 * 869 * @see #setForeground(java.awt.Color) 870 */ getForeground()871 public Color getForeground() 872 { 873 return SystemColor.menuText; 874 } 875 876 /** 877 * Returns the locale currently in use by this component. 878 * <br /> 879 * <br /> 880 * This abstract class has no property relating to the 881 * locale used by the component, so this method simply 882 * returns the default locale for the current instance 883 * of the Java Virtual Machine (JVM). Concrete subclasses 884 * which maintain such a property should override this method 885 * and provide the locale information more accurately. 886 * 887 * @return the default locale for this JVM instance 888 */ getLocale()889 public Locale getLocale() 890 { 891 return Locale.getDefault(); 892 } 893 894 /** 895 * Returns the location of the component, with co-ordinates 896 * relative to the parent component and using the co-ordinate 897 * space of the screen. Thus, the point (0,0) is the upper 898 * left corner of the parent component. 899 * <br /> 900 * <br /> 901 * Please note that this method depends on a correctly implemented 902 * version of the <code>getBounds()</code> method. Subclasses 903 * must provide the bounding rectangle via <code>getBounds()</code> 904 * in order for this method to work. 905 * 906 * @return the location of the component, relative to its parent 907 * 908 * @see #setLocation(java.awt.Point) 909 */ getLocation()910 public Point getLocation() 911 { 912 // Simply return the location of the bounding rectangle. 913 return getBounds().getLocation(); 914 } 915 916 /** 917 * Returns the location of the component, with co-ordinates 918 * relative to the screen. Thus, the point (0,0) is the upper 919 * left corner of the screen. null is returned if the component 920 * is either not on screen or if this property is unsupported. 921 * <br /> 922 * <br /> 923 * This abstract class knows nothing about how the component 924 * is drawn on screen, so this method simply returns null. 925 * Concrete subclasses which handle the drawing of an onscreen 926 * menu component should override this method and provide 927 * the appropriate information. 928 * 929 * @return the location of the component, relative to the screen 930 */ getLocationOnScreen()931 public Point getLocationOnScreen() 932 { 933 return null; 934 } 935 936 /** 937 * Returns the size of the component. 938 * <br /> 939 * <br /> 940 * Please note that this method depends on a correctly implemented 941 * version of the <code>getBounds()</code> method. Subclasses 942 * must provide the bounding rectangle via <code>getBounds()</code> 943 * in order for this method to work. 944 * 945 * @return the size of the component 946 * 947 * @see #setSize(java.awt.Dimension) 948 */ getSize()949 public Dimension getSize() 950 { 951 // Simply return the size of the bounding rectangle. 952 return getBounds().getSize(); 953 } 954 955 /** 956 * Returns true if the accessible child specified by the supplied index 957 * is currently selected. 958 * <br /> 959 * <br /> 960 * As the existence of children can not be determined from 961 * this abstract class, the implementation of this method 962 * is left to subclasses. 963 * 964 * @param index the index of the accessible child to check for selection 965 * 966 * @return false 967 */ isAccessibleChildSelected(int index)968 public boolean isAccessibleChildSelected(int index) 969 { 970 return false; 971 } 972 973 /** 974 * Returns true if this component is currently enabled. 975 * <br /> 976 * <br /> 977 * As this abstract component has no properties related to 978 * its enabled or disabled state, the implementation of this 979 * method is left to subclasses. 980 * 981 * @return false 982 * 983 * @see #setEnabled(boolean) 984 */ isEnabled()985 public boolean isEnabled() 986 { 987 return false; 988 } 989 990 /** 991 * Returns true if this component is included in the traversal 992 * of the current focus from one component to the other. 993 * <br /> 994 * <br /> 995 * As this abstract component has no properties related to 996 * its ability to accept the focus, the implementation of this 997 * method is left to subclasses. 998 * 999 * @return false 1000 */ isFocusTraversable()1001 public boolean isFocusTraversable() 1002 { 1003 return false; 1004 } 1005 1006 /** 1007 * Returns true if the component is being shown on screen. 1008 * A component is determined to be shown if it is visible, 1009 * and each parent component is also visible. Please note 1010 * that, even when a component is showing, it may still be 1011 * obscured by other components in front. This method only 1012 * determines if the component is being drawn on the screen. 1013 * <br /> 1014 * <br /> 1015 * As this abstract component and its parent have no properties 1016 * relating to visibility, the implementation of this method is 1017 * left to subclasses. 1018 * 1019 * @return false 1020 * 1021 * @see #isVisible() 1022 */ isShowing()1023 public boolean isShowing() 1024 { 1025 return false; 1026 } 1027 1028 /** 1029 * Returns true if the component is visible. A component may 1030 * be visible but not drawn on the screen if one of its parent 1031 * components is not visible. To determine if the component is 1032 * actually drawn on screen, <code>isShowing()</code> should be 1033 * used. 1034 * <br /> 1035 * <br /> 1036 * As this abstract component has no properties relating to its 1037 * visibility, the implementation of this method is left to subclasses. 1038 * 1039 * @return false 1040 * 1041 * @see #isShowing() 1042 * @see #setVisible(boolean) 1043 */ isVisible()1044 public boolean isVisible() 1045 { 1046 return false; 1047 } 1048 1049 /** 1050 * Removes the accessible child specified by the supplied index from 1051 * the list of currently selected children. If the child specified 1052 * is not selected, nothing happens. 1053 * <br /> 1054 * <br /> 1055 * As the existence of children can not be determined from 1056 * this abstract class, the implementation of this method 1057 * is left to subclasses. 1058 * 1059 * @param index the index of the <code>Accessible</code> child 1060 */ removeAccessibleSelection(int index)1061 public void removeAccessibleSelection(int index) 1062 { 1063 // Subclasses with children should implement this. 1064 } 1065 1066 /** 1067 * Removes the specified focus listener from the list of registered 1068 * focus listeners for this component. 1069 * 1070 * @param listener the listener to remove 1071 */ removeFocusListener(FocusListener listener)1072 public void removeFocusListener(FocusListener listener) 1073 { 1074 // Remove the focus listener from the chain. 1075 focusListener = AWTEventMulticaster.remove(focusListener, listener); 1076 } 1077 1078 /** 1079 * Requests that this component gains focus. This depends on the 1080 * component being focus traversable. 1081 * <br /> 1082 * <br /> 1083 * As this abstract component has no properties relating to its 1084 * focus traversability, or access to a peer with request focusing 1085 * abilities, the implementation of this method is left to subclasses. 1086 */ requestFocus()1087 public void requestFocus() 1088 { 1089 // Ignored. 1090 } 1091 1092 /** 1093 * Selects all <code>Accessible</code> children of this component which 1094 * it is possible to select. The component needs to support multiple 1095 * selections. 1096 * <br /> 1097 * <br /> 1098 * This abstract component provides a simplistic implementation of this 1099 * method, which ignores the ability of the component to support multiple 1100 * selections and simply uses <code>addAccessibleSelection</code> to 1101 * add each <code>Accessible</code> child to the selection. The last 1102 * <code>Accessible</code> component is thus selected for components 1103 * which don't support multiple selections. Concrete implementations should 1104 * override this with a more appopriate and efficient implementation, which 1105 * properly takes into account the ability of the component to support multiple 1106 * selections. 1107 */ selectAllAccessibleSelection()1108 public void selectAllAccessibleSelection() 1109 { 1110 // Simply call addAccessibleSelection() on all accessible children. 1111 for (int a = 0; a < getAccessibleChildrenCount(); ++a) 1112 { 1113 addAccessibleSelection(a); 1114 } 1115 } 1116 1117 /** 1118 * Sets the background color of the component to that specified. 1119 * Unspecified behaviour occurs when null is given as the new 1120 * background color. 1121 * <br /> 1122 * <br /> 1123 * This abstract class knows nothing about how the component 1124 * is drawn on screen, so this method simply ignores the supplied 1125 * color and continues to use the default system color. 1126 * Concrete subclasses which handle the drawing of an onscreen 1127 * menu component should override this method and provide 1128 * the appropriate information. 1129 * 1130 * @param color the new color to use for the background 1131 * 1132 * @see #getBackground() 1133 */ setBackground(Color color)1134 public void setBackground(Color color) 1135 { 1136 // Ignored. 1137 } 1138 1139 /** 1140 * Sets the height and width of the component, and its position 1141 * relative to this component's parent, to the values specified 1142 * by the supplied rectangle. Unspecified behaviour occurs when 1143 * null is given as the new bounds. 1144 * <br /> 1145 * <br /> 1146 * This abstract class knows nothing about how the component 1147 * is drawn on screen, so this method simply ignores the new 1148 * rectangle and continues to return null from <code>getBounds()</code>. 1149 * Concrete subclasses which handle the drawing of an onscreen 1150 * menu component should override this method and provide 1151 * the appropriate information. 1152 * 1153 * @param rectangle a rectangle which specifies the new bounds of 1154 * the component 1155 * 1156 * @see #getBounds() 1157 */ setBounds(Rectangle rectangle)1158 public void setBounds(Rectangle rectangle) 1159 { 1160 // Ignored. 1161 } 1162 1163 /** 1164 * Sets the <code>Cursor</code> used when the pointer is positioned over the 1165 * component. Unspecified behaviour occurs when null is given as the new 1166 * cursor. 1167 * <br /> 1168 * <br /> 1169 * This abstract class knows nothing about how the component 1170 * is drawn on screen, so this method simply ignores the new cursor 1171 * and continues to return the default system cursor. Concrete 1172 * subclasses which handle the drawing of an onscreen menu component 1173 * may override this method and provide the appropriate information. 1174 * 1175 * @param cursor the new cursor to use 1176 * 1177 * @see #getCursor() 1178 */ setCursor(Cursor cursor)1179 public void setCursor(Cursor cursor) 1180 { 1181 // Ignored. 1182 } 1183 1184 /** 1185 * Sets the enabled/disabled state of this component. 1186 * <br /> 1187 * <br /> 1188 * As this abstract component has no properties related to 1189 * its enabled or disabled state, the implementation of this 1190 * method is left to subclasses. 1191 * 1192 * @param enabled true if the component should be enabled, 1193 * false otherwise 1194 * 1195 * @see #isEnabled() 1196 */ setEnabled(boolean enabled)1197 public void setEnabled(boolean enabled) 1198 { 1199 // Ignored. 1200 } 1201 1202 /** 1203 * Sets the <code>Font</code> used for text created by this component. 1204 * Unspecified behaviour occurs when null is given as the new 1205 * font. 1206 * 1207 * @param font the new font to use for text. 1208 * @see #getFont() 1209 */ setFont(Font font)1210 public void setFont(Font font) 1211 { 1212 // Call the method of the enclosing component. 1213 MenuComponent.this.setFont(font); 1214 } 1215 1216 /** 1217 * Sets the foreground color of the component to that specified. 1218 * Unspecified behaviour occurs when null is given as the new 1219 * background color. 1220 * <br /> 1221 * <br /> 1222 * This abstract class knows nothing about how the component 1223 * is drawn on screen, so this method simply ignores the supplied 1224 * color and continues to return the default system text color used 1225 * for rendering menus. 1226 * Concrete subclasses which handle the drawing of an onscreen 1227 * menu component should override this method and provide 1228 * the appropriate information. 1229 * 1230 * @param color the new foreground color 1231 * 1232 * @see #getForeground() 1233 */ setForeground(Color color)1234 public void setForeground(Color color) 1235 { 1236 // Ignored. 1237 } 1238 1239 /** 1240 * Sets the location of the component, with co-ordinates 1241 * relative to the parent component and using the co-ordinate 1242 * space of the screen. Thus, the point (0,0) is the upper 1243 * left corner of the parent component. 1244 * <br /> 1245 * <br /> 1246 * Please note that this method depends on a correctly implemented 1247 * version of the <code>getBounds()</code> method. Subclasses 1248 * must provide the bounding rectangle via <code>getBounds()</code> 1249 * in order for this method to work. 1250 * 1251 * @param point the location of the component, relative to its parent 1252 * 1253 * @see #getLocation() 1254 */ setLocation(Point point)1255 public void setLocation(Point point) 1256 { 1257 getBounds().setLocation(point); 1258 } 1259 1260 /** 1261 * Sets the size of the component. 1262 * <br /> 1263 * <br /> 1264 * Please note that this method depends on a correctly implemented 1265 * version of the <code>getBounds()</code> method. Subclasses 1266 * must provide the bounding rectangle via <code>getBounds()</code> 1267 * in order for this method to work. 1268 * 1269 * @param size the new size of the component 1270 * 1271 * @see #getSize() 1272 */ setSize(Dimension size)1273 public void setSize(Dimension size) 1274 { 1275 getBounds().setSize(size); 1276 } 1277 1278 /** 1279 * Sets the visibility state of the component. A component may 1280 * be visible but not drawn on the screen if one of its parent 1281 * components is not visible. To determine if the component is 1282 * actually drawn on screen, <code>isShowing()</code> should be 1283 * used. 1284 * <br /> 1285 * <br /> 1286 * As this abstract component has no properties relating to its 1287 * visibility, the implementation of this method is left to subclasses. 1288 * 1289 * @param visibility the new visibility of the component -- true if 1290 * the component is visible, false if not 1291 * 1292 * @see #isShowing() 1293 * @see #isVisible() 1294 */ setVisible(boolean visibility)1295 public void setVisible(boolean visibility) 1296 { 1297 // Ignored. 1298 } 1299 1300 } 1301 1302 } 1303