0001 /*
0002 * Copyright 1995-2006 Sun Microsystems, Inc. All Rights Reserved.
0003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004 *
0005 * This code is free software; you can redistribute it and/or modify it
0006 * under the terms of the GNU General Public License version 2 only, as
0007 * published by the Free Software Foundation. Sun designates this
0008 * particular file as subject to the "Classpath" exception as provided
0009 * by Sun in the LICENSE file that accompanied this code.
0010 *
0011 * This code is distributed in the hope that it will be useful, but WITHOUT
0012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014 * version 2 for more details (a copy is included in the LICENSE file that
0015 * accompanied this code).
0016 *
0017 * You should have received a copy of the GNU General Public License version
0018 * 2 along with this work; if not, write to the Free Software Foundation,
0019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020 *
0021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022 * CA 95054 USA or visit www.sun.com if you need additional information or
0023 * have any questions.
0024 */
0025 package java.awt;
0026
0027 import java.awt.peer.MenuComponentPeer;
0028 import java.awt.event.ActionEvent;
0029 import java.io.IOException;
0030 import java.io.ObjectInputStream;
0031 import sun.awt.AppContext;
0032 import sun.awt.SunToolkit;
0033 import javax.accessibility.*;
0034
0035 /**
0036 * The abstract class <code>MenuComponent</code> is the superclass
0037 * of all menu-related components. In this respect, the class
0038 * <code>MenuComponent</code> is analogous to the abstract superclass
0039 * <code>Component</code> for AWT components.
0040 * <p>
0041 * Menu components receive and process AWT events, just as components do,
0042 * through the method <code>processEvent</code>.
0043 *
0044 * @version 1.88, 05/05/07
0045 * @author Arthur van Hoff
0046 * @since JDK1.0
0047 */
0048 public abstract class MenuComponent implements java.io.Serializable {
0049
0050 static {
0051 /* ensure that the necessary native libraries are loaded */
0052 Toolkit.loadLibraries();
0053 if (!GraphicsEnvironment.isHeadless()) {
0054 initIDs();
0055 }
0056 }
0057
0058 transient MenuComponentPeer peer;
0059 transient MenuContainer parent;
0060
0061 /**
0062 * The <code>AppContext</code> of the <code>MenuComponent</code>.
0063 * This is set in the constructor and never changes.
0064 */
0065 transient AppContext appContext;
0066
0067 /**
0068 * The menu component's font. This value can be
0069 * <code>null</code> at which point a default will be used.
0070 * This defaults to <code>null</code>.
0071 *
0072 * @serial
0073 * @see #setFont(Font)
0074 * @see #getFont()
0075 */
0076 Font font;
0077
0078 /**
0079 * The menu component's name, which defaults to <code>null</code>.
0080 * @serial
0081 * @see #getName()
0082 * @see #setName(String)
0083 */
0084 private String name;
0085
0086 /**
0087 * A variable to indicate whether a name is explicitly set.
0088 * If <code>true</code> the name will be set explicitly.
0089 * This defaults to <code>false</code>.
0090 * @serial
0091 * @see #setName(String)
0092 */
0093 private boolean nameExplicitlySet = false;
0094
0095 /**
0096 * Defaults to <code>false</code>.
0097 * @serial
0098 * @see #dispatchEvent(AWTEvent)
0099 */
0100 boolean newEventsOnly = false;
0101
0102 /*
0103 * Internal constants for serialization.
0104 */
0105 final static String actionListenerK = Component.actionListenerK;
0106 final static String itemListenerK = Component.itemListenerK;
0107
0108 /*
0109 * JDK 1.1 serialVersionUID
0110 */
0111 private static final long serialVersionUID = -4536902356223894379L;
0112
0113 /**
0114 * Creates a <code>MenuComponent</code>.
0115 * @exception HeadlessException if
0116 * <code>GraphicsEnvironment.isHeadless</code>
0117 * returns <code>true</code>
0118 * @see java.awt.GraphicsEnvironment#isHeadless
0119 */
0120 public MenuComponent() throws HeadlessException {
0121 GraphicsEnvironment.checkHeadless();
0122 appContext = AppContext.getAppContext();
0123 }
0124
0125 /**
0126 * Constructs a name for this <code>MenuComponent</code>.
0127 * Called by <code>getName</code> when the name is <code>null</code>.
0128 * @return a name for this <code>MenuComponent</code>
0129 */
0130 String constructComponentName() {
0131 return null; // For strict compliance with prior platform versions, a MenuComponent
0132 // that doesn't set its name should return null from
0133 // getName()
0134 }
0135
0136 /**
0137 * Gets the name of the menu component.
0138 * @return the name of the menu component
0139 * @see java.awt.MenuComponent#setName(java.lang.String)
0140 * @since JDK1.1
0141 */
0142 public String getName() {
0143 if (name == null && !nameExplicitlySet) {
0144 synchronized (this ) {
0145 if (name == null && !nameExplicitlySet)
0146 name = constructComponentName();
0147 }
0148 }
0149 return name;
0150 }
0151
0152 /**
0153 * Sets the name of the component to the specified string.
0154 * @param name the name of the menu component
0155 * @see java.awt.MenuComponent#getName
0156 * @since JDK1.1
0157 */
0158 public void setName(String name) {
0159 synchronized (this ) {
0160 this .name = name;
0161 nameExplicitlySet = true;
0162 }
0163 }
0164
0165 /**
0166 * Returns the parent container for this menu component.
0167 * @return the menu component containing this menu component,
0168 * or <code>null</code> if this menu component
0169 * is the outermost component, the menu bar itself
0170 */
0171 public MenuContainer getParent() {
0172 return getParent_NoClientCode();
0173 }
0174
0175 // NOTE: This method may be called by privileged threads.
0176 // This functionality is implemented in a package-private method
0177 // to insure that it cannot be overridden by client subclasses.
0178 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
0179 final MenuContainer getParent_NoClientCode() {
0180 return parent;
0181 }
0182
0183 /**
0184 * @deprecated As of JDK version 1.1,
0185 * programs should not directly manipulate peers.
0186 */
0187 @Deprecated
0188 public MenuComponentPeer getPeer() {
0189 return peer;
0190 }
0191
0192 /**
0193 * Gets the font used for this menu component.
0194 * @return the font used in this menu component, if there is one;
0195 * <code>null</code> otherwise
0196 * @see java.awt.MenuComponent#setFont
0197 */
0198 public Font getFont() {
0199 Font font = this .font;
0200 if (font != null) {
0201 return font;
0202 }
0203 MenuContainer parent = this .parent;
0204 if (parent != null) {
0205 return parent.getFont();
0206 }
0207 return null;
0208 }
0209
0210 // NOTE: This method may be called by privileged threads.
0211 // This functionality is implemented in a package-private method
0212 // to insure that it cannot be overridden by client subclasses.
0213 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
0214 final Font getFont_NoClientCode() {
0215 Font font = this .font;
0216 if (font != null) {
0217 return font;
0218 }
0219
0220 // The MenuContainer interface does not have getFont_NoClientCode()
0221 // and it cannot, because it must be package-private. Because of
0222 // this, we must manually cast classes that implement
0223 // MenuContainer.
0224 Object parent = this .parent;
0225 if (parent != null) {
0226 if (parent instanceof Component) {
0227 font = ((Component) parent).getFont_NoClientCode();
0228 } else if (parent instanceof MenuComponent) {
0229 font = ((MenuComponent) parent).getFont_NoClientCode();
0230 }
0231 }
0232 return font;
0233 } // getFont_NoClientCode()
0234
0235 /**
0236 * Sets the font to be used for this menu component to the specified
0237 * font. This font is also used by all subcomponents of this menu
0238 * component, unless those subcomponents specify a different font.
0239 * <p>
0240 * Some platforms may not support setting of all font attributes
0241 * of a menu component; in such cases, calling <code>setFont</code>
0242 * will have no effect on the unsupported font attributes of this
0243 * menu component. Unless subcomponents of this menu component
0244 * specify a different font, this font will be used by those
0245 * subcomponents if supported by the underlying platform.
0246 *
0247 * @param f the font to be set
0248 * @see #getFont
0249 * @see Font#getAttributes
0250 * @see java.awt.font.TextAttribute
0251 */
0252 public void setFont(Font f) {
0253 font = f;
0254 //Fixed 6312943: NullPointerException in method MenuComponent.setFont(Font)
0255 MenuComponentPeer peer = (MenuComponentPeer) this .peer;
0256 if (peer != null) {
0257 peer.setFont(f);
0258 }
0259 }
0260
0261 /**
0262 * Removes the menu component's peer. The peer allows us to modify the
0263 * appearance of the menu component without changing the functionality of
0264 * the menu component.
0265 */
0266 public void removeNotify() {
0267 synchronized (getTreeLock()) {
0268 MenuComponentPeer p = (MenuComponentPeer) this .peer;
0269 if (p != null) {
0270 Toolkit.getEventQueue().removeSourceEvents(this , true);
0271 this .peer = null;
0272 p.dispose();
0273 }
0274 }
0275 }
0276
0277 /**
0278 * Posts the specified event to the menu.
0279 * This method is part of the Java 1.0 event system
0280 * and it is maintained only for backwards compatibility.
0281 * Its use is discouraged, and it may not be supported
0282 * in the future.
0283 * @param evt the event which is to take place
0284 * @deprecated As of JDK version 1.1, replaced by {@link
0285 * #dispatchEvent(AWTEvent) dispatchEvent}.
0286 */
0287 @Deprecated
0288 public boolean postEvent(Event evt) {
0289 MenuContainer parent = this .parent;
0290 if (parent != null) {
0291 parent.postEvent(evt);
0292 }
0293 return false;
0294 }
0295
0296 /**
0297 * Delivers an event to this component or one of its sub components.
0298 * @param e the event
0299 */
0300 public final void dispatchEvent(AWTEvent e) {
0301 dispatchEventImpl(e);
0302 }
0303
0304 void dispatchEventImpl(AWTEvent e) {
0305 EventQueue.setCurrentEventAndMostRecentTime(e);
0306
0307 Toolkit.getDefaultToolkit().notifyAWTEventListeners(e);
0308
0309 if (newEventsOnly
0310 || (parent != null && parent instanceof MenuComponent && ((MenuComponent) parent).newEventsOnly)) {
0311 if (eventEnabled(e)) {
0312 processEvent(e);
0313 } else if (e instanceof ActionEvent && parent != null) {
0314 e.setSource(parent);
0315 ((MenuComponent) parent).dispatchEvent(e);
0316 }
0317
0318 } else { // backward compatibility
0319 Event olde = e.convertToOld();
0320 if (olde != null) {
0321 postEvent(olde);
0322 }
0323 }
0324 }
0325
0326 // REMIND: remove when filtering is done at lower level
0327 boolean eventEnabled(AWTEvent e) {
0328 return false;
0329 }
0330
0331 /**
0332 * Processes events occurring on this menu component.
0333 * <p>Note that if the event parameter is <code>null</code>
0334 * the behavior is unspecified and may result in an
0335 * exception.
0336 *
0337 * @param e the event
0338 * @since JDK1.1
0339 */
0340 protected void processEvent(AWTEvent e) {
0341 }
0342
0343 /**
0344 * Returns a string representing the state of this
0345 * <code>MenuComponent</code>. This method is intended to be used
0346 * only for debugging purposes, and the content and format of the
0347 * returned string may vary between implementations. The returned
0348 * string may be empty but may not be <code>null</code>.
0349 *
0350 * @return the parameter string of this menu component
0351 */
0352 protected String paramString() {
0353 String this Name = getName();
0354 return (this Name != null ? this Name : "");
0355 }
0356
0357 /**
0358 * Returns a representation of this menu component as a string.
0359 * @return a string representation of this menu component
0360 */
0361 public String toString() {
0362 return getClass().getName() + "[" + paramString() + "]";
0363 }
0364
0365 /**
0366 * Gets this component's locking object (the object that owns the thread
0367 * sychronization monitor) for AWT component-tree and layout
0368 * operations.
0369 * @return this component's locking object
0370 */
0371 protected final Object getTreeLock() {
0372 return Component.LOCK;
0373 }
0374
0375 /**
0376 * Reads the menu component from an object input stream.
0377 *
0378 * @param s the <code>ObjectInputStream</code> to read
0379 * @exception HeadlessException if
0380 * <code>GraphicsEnvironment.isHeadless</code> returns
0381 * <code>true</code>
0382 * @serial
0383 * @see java.awt.GraphicsEnvironment#isHeadless
0384 */
0385 private void readObject(ObjectInputStream s)
0386 throws ClassNotFoundException, IOException,
0387 HeadlessException {
0388 GraphicsEnvironment.checkHeadless();
0389 s.defaultReadObject();
0390
0391 appContext = AppContext.getAppContext();
0392 }
0393
0394 /**
0395 * Initialize JNI field and method IDs.
0396 */
0397 private static native void initIDs();
0398
0399 /*
0400 * --- Accessibility Support ---
0401 *
0402 * MenuComponent will contain all of the methods in interface Accessible,
0403 * though it won't actually implement the interface - that will be up
0404 * to the individual objects which extend MenuComponent.
0405 */
0406
0407 AccessibleContext accessibleContext = null;
0408
0409 /**
0410 * Gets the <code>AccessibleContext</code> associated with
0411 * this <code>MenuComponent</code>.
0412 *
0413 * The method implemented by this base class returns <code>null</code>.
0414 * Classes that extend <code>MenuComponent</code>
0415 * should implement this method to return the
0416 * <code>AccessibleContext</code> associated with the subclass.
0417 *
0418 * @return the <code>AccessibleContext</code> of this
0419 * <code>MenuComponent</code>
0420 * @since 1.3
0421 */
0422 public AccessibleContext getAccessibleContext() {
0423 return accessibleContext;
0424 }
0425
0426 /**
0427 * Inner class of <code>MenuComponent</code> used to provide
0428 * default support for accessibility. This class is not meant
0429 * to be used directly by application developers, but is instead
0430 * meant only to be subclassed by menu component developers.
0431 * <p>
0432 * The class used to obtain the accessible role for this object.
0433 * @since 1.3
0434 */
0435 protected abstract class AccessibleAWTMenuComponent extends
0436 AccessibleContext implements java.io.Serializable,
0437 AccessibleComponent, AccessibleSelection {
0438 /*
0439 * JDK 1.3 serialVersionUID
0440 */
0441 private static final long serialVersionUID = -4269533416223798698L;
0442
0443 /**
0444 * Although the class is abstract, this should be called by
0445 * all sub-classes.
0446 */
0447 protected AccessibleAWTMenuComponent() {
0448 }
0449
0450 // AccessibleContext methods
0451 //
0452
0453 /**
0454 * Gets the <code>AccessibleSelection</code> associated with this
0455 * object which allows its <code>Accessible</code> children to be selected.
0456 *
0457 * @return <code>AccessibleSelection</code> if supported by object;
0458 * else return <code>null</code>
0459 * @see AccessibleSelection
0460 */
0461 public AccessibleSelection getAccessibleSelection() {
0462 return this ;
0463 }
0464
0465 /**
0466 * Gets the accessible name of this object. This should almost never
0467 * return <code>java.awt.MenuComponent.getName</code>, as that
0468 * generally isn't a localized name, and doesn't have meaning for the
0469 * user. If the object is fundamentally a text object (e.g. a menu item), the
0470 * accessible name should be the text of the object (e.g. "save").
0471 * If the object has a tooltip, the tooltip text may also be an
0472 * appropriate String to return.
0473 *
0474 * @return the localized name of the object -- can be <code>null</code>
0475 * if this object does not have a name
0476 * @see AccessibleContext#setAccessibleName
0477 */
0478 public String getAccessibleName() {
0479 return accessibleName;
0480 }
0481
0482 /**
0483 * Gets the accessible description of this object. This should be
0484 * a concise, localized description of what this object is - what
0485 * is its meaning to the user. If the object has a tooltip, the
0486 * tooltip text may be an appropriate string to return, assuming
0487 * it contains a concise description of the object (instead of just
0488 * the name of the object - e.g. a "Save" icon on a toolbar that
0489 * had "save" as the tooltip text shouldn't return the tooltip
0490 * text as the description, but something like "Saves the current
0491 * text document" instead).
0492 *
0493 * @return the localized description of the object -- can be
0494 * <code>null</code> if this object does not have a description
0495 * @see AccessibleContext#setAccessibleDescription
0496 */
0497 public String getAccessibleDescription() {
0498 return accessibleDescription;
0499 }
0500
0501 /**
0502 * Gets the role of this object.
0503 *
0504 * @return an instance of <code>AccessibleRole</code>
0505 * describing the role of the object
0506 * @see AccessibleRole
0507 */
0508 public AccessibleRole getAccessibleRole() {
0509 return AccessibleRole.AWT_COMPONENT; // Non-specific -- overridden in subclasses
0510 }
0511
0512 /**
0513 * Gets the state of this object.
0514 *
0515 * @return an instance of <code>AccessibleStateSet</code>
0516 * containing the current state set of the object
0517 * @see AccessibleState
0518 */
0519 public AccessibleStateSet getAccessibleStateSet() {
0520 return MenuComponent.this .getAccessibleStateSet();
0521 }
0522
0523 /**
0524 * Gets the <code>Accessible</code> parent of this object.
0525 * If the parent of this object implements <code>Accessible</code>,
0526 * this method should simply return <code>getParent</code>.
0527 *
0528 * @return the <code>Accessible</code> parent of this object -- can
0529 * be <code>null</code> if this object does not have an
0530 * <code>Accessible</code> parent
0531 */
0532 public Accessible getAccessibleParent() {
0533 if (accessibleParent != null) {
0534 return accessibleParent;
0535 } else {
0536 MenuContainer parent = MenuComponent.this .getParent();
0537 if (parent instanceof Accessible) {
0538 return (Accessible) parent;
0539 }
0540 }
0541 return null;
0542 }
0543
0544 /**
0545 * Gets the index of this object in its accessible parent.
0546 *
0547 * @return the index of this object in its parent; -1 if this
0548 * object does not have an accessible parent
0549 * @see #getAccessibleParent
0550 */
0551 public int getAccessibleIndexInParent() {
0552 return MenuComponent.this .getAccessibleIndexInParent();
0553 }
0554
0555 /**
0556 * Returns the number of accessible children in the object. If all
0557 * of the children of this object implement <code>Accessible</code>,
0558 * then this method should return the number of children of this object.
0559 *
0560 * @return the number of accessible children in the object
0561 */
0562 public int getAccessibleChildrenCount() {
0563 return 0; // MenuComponents don't have children
0564 }
0565
0566 /**
0567 * Returns the nth <code>Accessible</code> child of the object.
0568 *
0569 * @param i zero-based index of child
0570 * @return the nth Accessible child of the object
0571 */
0572 public Accessible getAccessibleChild(int i) {
0573 return null; // MenuComponents don't have children
0574 }
0575
0576 /**
0577 * Returns the locale of this object.
0578 *
0579 * @return the locale of this object
0580 */
0581 public java.util.Locale getLocale() {
0582 MenuContainer parent = MenuComponent.this .getParent();
0583 if (parent instanceof Component)
0584 return ((Component) parent).getLocale();
0585 else
0586 return java.util.Locale.getDefault();
0587 }
0588
0589 /**
0590 * Gets the <code>AccessibleComponent</code> associated with
0591 * this object if one exists. Otherwise return <code>null</code>.
0592 *
0593 * @return the component
0594 */
0595 public AccessibleComponent getAccessibleComponent() {
0596 return this ;
0597 }
0598
0599 // AccessibleComponent methods
0600 //
0601 /**
0602 * Gets the background color of this object.
0603 *
0604 * @return the background color, if supported, of the object;
0605 * otherwise, <code>null</code>
0606 */
0607 public Color getBackground() {
0608 return null; // Not supported for MenuComponents
0609 }
0610
0611 /**
0612 * Sets the background color of this object.
0613 * (For transparency, see <code>isOpaque</code>.)
0614 *
0615 * @param c the new <code>Color</code> for the background
0616 * @see Component#isOpaque
0617 */
0618 public void setBackground(Color c) {
0619 // Not supported for MenuComponents
0620 }
0621
0622 /**
0623 * Gets the foreground color of this object.
0624 *
0625 * @return the foreground color, if supported, of the object;
0626 * otherwise, <code>null</code>
0627 */
0628 public Color getForeground() {
0629 return null; // Not supported for MenuComponents
0630 }
0631
0632 /**
0633 * Sets the foreground color of this object.
0634 *
0635 * @param c the new <code>Color</code> for the foreground
0636 */
0637 public void setForeground(Color c) {
0638 // Not supported for MenuComponents
0639 }
0640
0641 /**
0642 * Gets the <code>Cursor</code> of this object.
0643 *
0644 * @return the <code>Curso</code>, if supported, of the object;
0645 * otherwise, <code>null</code>
0646 */
0647 public Cursor getCursor() {
0648 return null; // Not supported for MenuComponents
0649 }
0650
0651 /**
0652 * Sets the <code>Cursor</code> of this object.
0653 * <p>
0654 * The method may have no visual effect if the Java platform
0655 * implementation and/or the native system do not support
0656 * changing the mouse cursor shape.
0657 * @param cursor the new <code>Cursor</code> for the object
0658 */
0659 public void setCursor(Cursor cursor) {
0660 // Not supported for MenuComponents
0661 }
0662
0663 /**
0664 * Gets the <code>Font</code> of this object.
0665 *
0666 * @return the <code>Font</code>,if supported, for the object;
0667 * otherwise, <code>null</code>
0668 */
0669 public Font getFont() {
0670 return MenuComponent.this .getFont();
0671 }
0672
0673 /**
0674 * Sets the <code>Font</code> of this object.
0675 *
0676 * @param f the new <code>Font</code> for the object
0677 */
0678 public void setFont(Font f) {
0679 MenuComponent.this .setFont(f);
0680 }
0681
0682 /**
0683 * Gets the <code>FontMetrics</code> of this object.
0684 *
0685 * @param f the <code>Font</code>
0686 * @return the FontMetrics, if supported, the object;
0687 * otherwise, <code>null</code>
0688 * @see #getFont
0689 */
0690 public FontMetrics getFontMetrics(Font f) {
0691 return null; // Not supported for MenuComponents
0692 }
0693
0694 /**
0695 * Determines if the object is enabled.
0696 *
0697 * @return true if object is enabled; otherwise, false
0698 */
0699 public boolean isEnabled() {
0700 return true; // Not supported for MenuComponents
0701 }
0702
0703 /**
0704 * Sets the enabled state of the object.
0705 *
0706 * @param b if true, enables this object; otherwise, disables it
0707 */
0708 public void setEnabled(boolean b) {
0709 // Not supported for MenuComponents
0710 }
0711
0712 /**
0713 * Determines if the object is visible. Note: this means that the
0714 * object intends to be visible; however, it may not in fact be
0715 * showing on the screen because one of the objects that this object
0716 * is contained by is not visible. To determine if an object is
0717 * showing on the screen, use <code>isShowing</code>.
0718 *
0719 * @return true if object is visible; otherwise, false
0720 */
0721 public boolean isVisible() {
0722 return true; // Not supported for MenuComponents
0723 }
0724
0725 /**
0726 * Sets the visible state of the object.
0727 *
0728 * @param b if true, shows this object; otherwise, hides it
0729 */
0730 public void setVisible(boolean b) {
0731 // Not supported for MenuComponents
0732 }
0733
0734 /**
0735 * Determines if the object is showing. This is determined by checking
0736 * the visibility of the object and ancestors of the object. Note:
0737 * this will return true even if the object is obscured by another
0738 * (for example, it happens to be underneath a menu that was pulled
0739 * down).
0740 *
0741 * @return true if object is showing; otherwise, false
0742 */
0743 public boolean isShowing() {
0744 return true; // Not supported for MenuComponents
0745 }
0746
0747 /**
0748 * Checks whether the specified point is within this object's bounds,
0749 * where the point's x and y coordinates are defined to be relative to
0750 * the coordinate system of the object.
0751 *
0752 * @param p the <code>Point</code> relative to the coordinate
0753 * system of the object
0754 * @return true if object contains <code>Point</code>; otherwise false
0755 */
0756 public boolean contains(Point p) {
0757 return false; // Not supported for MenuComponents
0758 }
0759
0760 /**
0761 * Returns the location of the object on the screen.
0762 *
0763 * @return location of object on screen -- can be <code>null</code>
0764 * if this object is not on the screen
0765 */
0766 public Point getLocationOnScreen() {
0767 return null; // Not supported for MenuComponents
0768 }
0769
0770 /**
0771 * Gets the location of the object relative to the parent in the form
0772 * of a point specifying the object's top-left corner in the screen's
0773 * coordinate space.
0774 *
0775 * @return an instance of <code>Point</code> representing the
0776 * top-left corner of the object's bounds in the coordinate
0777 * space of the screen; <code>null</code> if
0778 * this object or its parent are not on the screen
0779 */
0780 public Point getLocation() {
0781 return null; // Not supported for MenuComponents
0782 }
0783
0784 /**
0785 * Sets the location of the object relative to the parent.
0786 */
0787 public void setLocation(Point p) {
0788 // Not supported for MenuComponents
0789 }
0790
0791 /**
0792 * Gets the bounds of this object in the form of a
0793 * <code>Rectangle</code> object.
0794 * The bounds specify this object's width, height, and location
0795 * relative to its parent.
0796 *
0797 * @return a rectangle indicating this component's bounds;
0798 * <code>null</code> if this object is not on the screen
0799 */
0800 public Rectangle getBounds() {
0801 return null; // Not supported for MenuComponents
0802 }
0803
0804 /**
0805 * Sets the bounds of this object in the form of a
0806 * <code>Rectangle</code> object.
0807 * The bounds specify this object's width, height, and location
0808 * relative to its parent.
0809 *
0810 * @param r a rectangle indicating this component's bounds
0811 */
0812 public void setBounds(Rectangle r) {
0813 // Not supported for MenuComponents
0814 }
0815
0816 /**
0817 * Returns the size of this object in the form of a
0818 * <code>Dimension</code> object. The height field of
0819 * the <code>Dimension</code> object contains this object's
0820 * height, and the width field of the <code>Dimension</code>
0821 * object contains this object's width.
0822 *
0823 * @return a <code>Dimension</code> object that indicates the
0824 * size of this component; <code>null</code>
0825 * if this object is not on the screen
0826 */
0827 public Dimension getSize() {
0828 return null; // Not supported for MenuComponents
0829 }
0830
0831 /**
0832 * Resizes this object.
0833 *
0834 * @param d - the <code>Dimension</code> specifying the
0835 * new size of the object
0836 */
0837 public void setSize(Dimension d) {
0838 // Not supported for MenuComponents
0839 }
0840
0841 /**
0842 * Returns the <code>Accessible</code> child, if one exists,
0843 * contained at the local coordinate <code>Point</code>.
0844 * If there is no <code>Accessible</code> child, <code>null</code>
0845 * is returned.
0846 *
0847 * @param p the point defining the top-left corner of the
0848 * <code>Accessible</code>, given in the coordinate space
0849 * of the object's parent
0850 * @return the <code>Accessible</code>, if it exists,
0851 * at the specified location; else <code>null</code>
0852 */
0853 public Accessible getAccessibleAt(Point p) {
0854 return null; // MenuComponents don't have children
0855 }
0856
0857 /**
0858 * Returns whether this object can accept focus or not.
0859 *
0860 * @return true if object can accept focus; otherwise false
0861 */
0862 public boolean isFocusTraversable() {
0863 return true; // Not supported for MenuComponents
0864 }
0865
0866 /**
0867 * Requests focus for this object.
0868 */
0869 public void requestFocus() {
0870 // Not supported for MenuComponents
0871 }
0872
0873 /**
0874 * Adds the specified focus listener to receive focus events from this
0875 * component.
0876 *
0877 * @param l the focus listener
0878 */
0879 public void addFocusListener(java.awt.event.FocusListener l) {
0880 // Not supported for MenuComponents
0881 }
0882
0883 /**
0884 * Removes the specified focus listener so it no longer receives focus
0885 * events from this component.
0886 *
0887 * @param l the focus listener
0888 */
0889 public void removeFocusListener(java.awt.event.FocusListener l) {
0890 // Not supported for MenuComponents
0891 }
0892
0893 // AccessibleSelection methods
0894 //
0895
0896 /**
0897 * Returns the number of <code>Accessible</code> children currently selected.
0898 * If no children are selected, the return value will be 0.
0899 *
0900 * @return the number of items currently selected
0901 */
0902 public int getAccessibleSelectionCount() {
0903 return 0; // To be fully implemented in a future release
0904 }
0905
0906 /**
0907 * Returns an <code>Accessible</code> representing the specified
0908 * selected child in the object. If there isn't a selection, or there are
0909 * fewer children selected than the integer passed in, the return
0910 * value will be <code>null</code>.
0911 * <p>Note that the index represents the i-th selected child, which
0912 * is different from the i-th child.
0913 *
0914 * @param i the zero-based index of selected children
0915 * @return the i-th selected child
0916 * @see #getAccessibleSelectionCount
0917 */
0918 public Accessible getAccessibleSelection(int i) {
0919 return null; // To be fully implemented in a future release
0920 }
0921
0922 /**
0923 * Determines if the current child of this object is selected.
0924 *
0925 * @return true if the current child of this object is selected;
0926 * else false
0927 * @param i the zero-based index of the child in this
0928 * <code>Accessible</code> object
0929 * @see AccessibleContext#getAccessibleChild
0930 */
0931 public boolean isAccessibleChildSelected(int i) {
0932 return false; // To be fully implemented in a future release
0933 }
0934
0935 /**
0936 * Adds the specified <code>Accessible</code> child of the object
0937 * to the object's selection. If the object supports multiple selections,
0938 * the specified child is added to any existing selection, otherwise
0939 * it replaces any existing selection in the object. If the
0940 * specified child is already selected, this method has no effect.
0941 *
0942 * @param i the zero-based index of the child
0943 * @see AccessibleContext#getAccessibleChild
0944 */
0945 public void addAccessibleSelection(int i) {
0946 // To be fully implemented in a future release
0947 }
0948
0949 /**
0950 * Removes the specified child of the object from the object's
0951 * selection. If the specified item isn't currently selected, this
0952 * method has no effect.
0953 *
0954 * @param i the zero-based index of the child
0955 * @see AccessibleContext#getAccessibleChild
0956 */
0957 public void removeAccessibleSelection(int i) {
0958 // To be fully implemented in a future release
0959 }
0960
0961 /**
0962 * Clears the selection in the object, so that no children in the
0963 * object are selected.
0964 */
0965 public void clearAccessibleSelection() {
0966 // To be fully implemented in a future release
0967 }
0968
0969 /**
0970 * Causes every child of the object to be selected
0971 * if the object supports multiple selections.
0972 */
0973 public void selectAllAccessibleSelection() {
0974 // To be fully implemented in a future release
0975 }
0976
0977 } // inner class AccessibleAWTComponent
0978
0979 /**
0980 * Gets the index of this object in its accessible parent.
0981 *
0982 * @return -1 if this object does not have an accessible parent;
0983 * otherwise, the index of the child in its accessible parent.
0984 */
0985 int getAccessibleIndexInParent() {
0986 MenuContainer localParent = parent;
0987 if (!(localParent instanceof MenuComponent)) {
0988 // MenuComponents only have accessible index when inside MenuComponents
0989 return -1;
0990 }
0991 MenuComponent localParentMenu = (MenuComponent) localParent;
0992 return localParentMenu.getAccessibleChildIndex(this );
0993 }
0994
0995 /**
0996 * Gets the index of the child within this MenuComponent.
0997 *
0998 * @param child MenuComponent whose index we are interested in.
0999 * @return -1 if this object doesn't contain the child,
1000 * otherwise, index of the child.
1001 */
1002 int getAccessibleChildIndex(MenuComponent child) {
1003 return -1; // Overridden in subclasses.
1004 }
1005
1006 /**
1007 * Gets the state of this object.
1008 *
1009 * @return an instance of <code>AccessibleStateSet</code>
1010 * containing the current state set of the object
1011 * @see AccessibleState
1012 */
1013 AccessibleStateSet getAccessibleStateSet() {
1014 AccessibleStateSet states = new AccessibleStateSet();
1015 return states;
1016 }
1017
1018 }
|