1 /* 2 * Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 package java.awt; 26 27 import java.awt.peer.TextFieldPeer; 28 import java.awt.event.*; 29 import java.util.EventListener; 30 import java.io.ObjectOutputStream; 31 import java.io.ObjectInputStream; 32 import java.io.IOException; 33 import javax.accessibility.*; 34 35 36 /** 37 * A <code>TextField</code> object is a text component 38 * that allows for the editing of a single line of text. 39 * <p> 40 * For example, the following image depicts a frame with four 41 * text fields of varying widths. Two of these text fields 42 * display the predefined text <code>"Hello"</code>. 43 * <p> 44 * <img src="doc-files/TextField-1.gif" alt="The preceding text describes this image." 45 * style="float:center; margin: 7px 10px;"> 46 * <p> 47 * Here is the code that produces these four text fields: 48 * 49 * <hr><blockquote><pre> 50 * TextField tf1, tf2, tf3, tf4; 51 * // a blank text field 52 * tf1 = new TextField(); 53 * // blank field of 20 columns 54 * tf2 = new TextField("", 20); 55 * // predefined text displayed 56 * tf3 = new TextField("Hello!"); 57 * // predefined text in 30 columns 58 * tf4 = new TextField("Hello", 30); 59 * </pre></blockquote><hr> 60 * <p> 61 * Every time the user types a key in the text field, one or 62 * more key events are sent to the text field. A <code>KeyEvent</code> 63 * may be one of three types: keyPressed, keyReleased, or keyTyped. 64 * The properties of a key event indicate which of these types 65 * it is, as well as additional information about the event, 66 * such as what modifiers are applied to the key event and the 67 * time at which the event occurred. 68 * <p> 69 * The key event is passed to every <code>KeyListener</code> 70 * or <code>KeyAdapter</code> object which registered to receive such 71 * events using the component's <code>addKeyListener</code> method. 72 * (<code>KeyAdapter</code> objects implement the 73 * <code>KeyListener</code> interface.) 74 * <p> 75 * It is also possible to fire an <code>ActionEvent</code>. 76 * If action events are enabled for the text field, they may 77 * be fired by pressing the <code>Return</code> key. 78 * <p> 79 * The <code>TextField</code> class's <code>processEvent</code> 80 * method examines the action event and passes it along to 81 * <code>processActionEvent</code>. The latter method redirects the 82 * event to any <code>ActionListener</code> objects that have 83 * registered to receive action events generated by this 84 * text field. 85 * 86 * @author Sami Shaio 87 * @see java.awt.event.KeyEvent 88 * @see java.awt.event.KeyAdapter 89 * @see java.awt.event.KeyListener 90 * @see java.awt.event.ActionEvent 91 * @see java.awt.Component#addKeyListener 92 * @see java.awt.TextField#processEvent 93 * @see java.awt.TextField#processActionEvent 94 * @see java.awt.TextField#addActionListener 95 * @since 1.0 96 */ 97 public class TextField extends TextComponent { 98 99 /** 100 * The number of columns in the text field. 101 * A column is an approximate average character 102 * width that is platform-dependent. 103 * Guaranteed to be non-negative. 104 * 105 * @serial 106 * @see #setColumns(int) 107 * @see #getColumns() 108 */ 109 int columns; 110 111 /** 112 * The echo character, which is used when 113 * the user wishes to disguise the characters 114 * typed into the text field. 115 * The disguises are removed if echoChar = <code>0</code>. 116 * 117 * @serial 118 * @see #getEchoChar() 119 * @see #setEchoChar(char) 120 * @see #echoCharIsSet() 121 */ 122 char echoChar; 123 124 transient ActionListener actionListener; 125 126 private static final String base = "textfield"; 127 private static int nameCounter = 0; 128 129 /* 130 * JDK 1.1 serialVersionUID 131 */ 132 private static final long serialVersionUID = -2966288784432217853L; 133 134 /** 135 * Initialize JNI field and method ids 136 */ 137 private static native void initIDs(); 138 139 static { 140 /* ensure that the necessary native libraries are loaded */ 141 Toolkit.loadLibraries(); 142 if (!GraphicsEnvironment.isHeadless()) { 143 initIDs(); 144 } 145 } 146 147 /** 148 * Constructs a new text field. 149 * @exception HeadlessException if GraphicsEnvironment.isHeadless() 150 * returns true. 151 * @see java.awt.GraphicsEnvironment#isHeadless 152 */ 153 public TextField() throws HeadlessException { 154 this("", 0); 155 } 156 157 /** 158 * Constructs a new text field initialized with the specified text. 159 * @param text the text to be displayed. If 160 * <code>text</code> is <code>null</code>, the empty 161 * string <code>""</code> will be displayed. 162 * @exception HeadlessException if GraphicsEnvironment.isHeadless() 163 * returns true. 164 * @see java.awt.GraphicsEnvironment#isHeadless 165 */ 166 public TextField(String text) throws HeadlessException { 167 this(text, (text != null) ? text.length() : 0); 168 } 169 170 /** 171 * Constructs a new empty text field with the specified number 172 * of columns. A column is an approximate average character 173 * width that is platform-dependent. 174 * @param columns the number of columns. If 175 * <code>columns</code> is less than <code>0</code>, 176 * <code>columns</code> is set to <code>0</code>. 177 * @exception HeadlessException if GraphicsEnvironment.isHeadless() 178 * returns true. 179 * @see java.awt.GraphicsEnvironment#isHeadless 180 */ 181 public TextField(int columns) throws HeadlessException { 182 this("", columns); 183 } 184 185 /** 186 * Constructs a new text field initialized with the specified text 187 * to be displayed, and wide enough to hold the specified 188 * number of columns. A column is an approximate average character 189 * width that is platform-dependent. 190 * @param text the text to be displayed. If 191 * <code>text</code> is <code>null</code>, the empty 192 * string <code>""</code> will be displayed. 193 * @param columns the number of columns. If 194 * <code>columns</code> is less than <code>0</code>, 195 * <code>columns</code> is set to <code>0</code>. 196 * @exception HeadlessException if GraphicsEnvironment.isHeadless() 197 * returns true. 198 * @see java.awt.GraphicsEnvironment#isHeadless 199 */ 200 public TextField(String text, int columns) throws HeadlessException { 201 super(replaceEOL(text)); 202 this.columns = (columns >= 0) ? columns : 0; 203 } 204 205 /** 206 * Construct a name for this component. Called by getName() when the 207 * name is null. 208 */ 209 String constructComponentName() { 210 synchronized (TextField.class) { 211 return base + nameCounter++; 212 } 213 } 214 215 /** 216 * Creates the TextField's peer. The peer allows us to modify the 217 * appearance of the TextField without changing its functionality. 218 */ 219 public void addNotify() { 220 synchronized (getTreeLock()) { 221 if (peer == null) 222 peer = getComponentFactory().createTextField(this); 223 super.addNotify(); 224 } 225 } 226 227 /** 228 * Gets the character that is to be used for echoing. 229 * <p> 230 * An echo character is useful for text fields where 231 * user input should not be echoed to the screen, as in 232 * the case of a text field for entering a password. 233 * If <code>echoChar</code> = <code>0</code>, user 234 * input is echoed to the screen unchanged. 235 * <p> 236 * A Java platform implementation may support only a limited, 237 * non-empty set of echo characters. This function returns the 238 * echo character originally requested via setEchoChar(). The echo 239 * character actually used by the TextField implementation might be 240 * different. 241 * @return the echo character for this text field. 242 * @see java.awt.TextField#echoCharIsSet 243 * @see java.awt.TextField#setEchoChar 244 */ 245 public char getEchoChar() { 246 return echoChar; 247 } 248 249 /** 250 * Sets the echo character for this text field. 251 * <p> 252 * An echo character is useful for text fields where 253 * user input should not be echoed to the screen, as in 254 * the case of a text field for entering a password. 255 * Setting <code>echoChar</code> = <code>0</code> allows 256 * user input to be echoed to the screen again. 257 * <p> 258 * A Java platform implementation may support only a limited, 259 * non-empty set of echo characters. Attempts to set an 260 * unsupported echo character will cause the default echo 261 * character to be used instead. Subsequent calls to getEchoChar() 262 * will return the echo character originally requested. This might 263 * or might not be identical to the echo character actually 264 * used by the TextField implementation. 265 * @param c the echo character for this text field. 266 * @see java.awt.TextField#echoCharIsSet 267 * @see java.awt.TextField#getEchoChar 268 * @since 1.1 269 */ 270 public void setEchoChar(char c) { 271 setEchoCharacter(c); 272 } 273 274 /** 275 * Sets the character to be echoed when protected input is displayed. 276 * 277 * @param c the echo character for this text field 278 * 279 * @deprecated As of JDK version 1.1, 280 * replaced by <code>setEchoChar(char)</code>. 281 */ 282 @Deprecated 283 public synchronized void setEchoCharacter(char c) { 284 if (echoChar != c) { 285 echoChar = c; 286 TextFieldPeer peer = (TextFieldPeer)this.peer; 287 if (peer != null) { 288 peer.setEchoChar(c); 289 } 290 } 291 } 292 293 /** 294 * Sets the text that is presented by this 295 * text component to be the specified text. 296 * @param t the new text. 297 * @see java.awt.TextComponent#getText 298 */ 299 public void setText(String t) { 300 super.setText(replaceEOL(t)); 301 302 // This could change the preferred size of the Component. 303 invalidateIfValid(); 304 } 305 306 /** 307 * Replaces EOL characters from the text variable with a space character. 308 * @param text the new text. 309 * @return Returns text after replacing EOL characters. 310 */ 311 private static String replaceEOL(String text) { 312 if (text == null) { 313 return text; 314 } 315 String[] strEOLs = {System.lineSeparator(), "\n"}; 316 for (String eol : strEOLs) { 317 if (text.contains(eol)) { 318 text = text.replace(eol, " "); 319 } 320 } 321 return text; 322 } 323 324 325 /** 326 * Indicates whether or not this text field has a 327 * character set for echoing. 328 * <p> 329 * An echo character is useful for text fields where 330 * user input should not be echoed to the screen, as in 331 * the case of a text field for entering a password. 332 * @return <code>true</code> if this text field has 333 * a character set for echoing; 334 * <code>false</code> otherwise. 335 * @see java.awt.TextField#setEchoChar 336 * @see java.awt.TextField#getEchoChar 337 */ 338 public boolean echoCharIsSet() { 339 return echoChar != 0; 340 } 341 342 /** 343 * Gets the number of columns in this text field. A column is an 344 * approximate average character width that is platform-dependent. 345 * @return the number of columns. 346 * @see java.awt.TextField#setColumns 347 * @since 1.1 348 */ 349 public int getColumns() { 350 return columns; 351 } 352 353 /** 354 * Sets the number of columns in this text field. A column is an 355 * approximate average character width that is platform-dependent. 356 * @param columns the number of columns. 357 * @see java.awt.TextField#getColumns 358 * @exception IllegalArgumentException if the value 359 * supplied for <code>columns</code> 360 * is less than <code>0</code>. 361 * @since 1.1 362 */ 363 public void setColumns(int columns) { 364 int oldVal; 365 synchronized (this) { 366 oldVal = this.columns; 367 if (columns < 0) { 368 throw new IllegalArgumentException("columns less than zero."); 369 } 370 if (columns != oldVal) { 371 this.columns = columns; 372 } 373 } 374 375 if (columns != oldVal) { 376 invalidate(); 377 } 378 } 379 380 /** 381 * Gets the preferred size of this text field 382 * with the specified number of columns. 383 * @param columns the number of columns 384 * in this text field. 385 * @return the preferred dimensions for 386 * displaying this text field. 387 * @since 1.1 388 */ 389 public Dimension getPreferredSize(int columns) { 390 return preferredSize(columns); 391 } 392 393 /** 394 * Returns the preferred size for this text field 395 * with the specified number of columns. 396 * 397 * @param columns the number of columns 398 * @return the preferred size for the text field 399 * 400 * @deprecated As of JDK version 1.1, 401 * replaced by <code>getPreferredSize(int)</code>. 402 */ 403 @Deprecated 404 public Dimension preferredSize(int columns) { 405 synchronized (getTreeLock()) { 406 TextFieldPeer peer = (TextFieldPeer)this.peer; 407 return (peer != null) ? 408 peer.getPreferredSize(columns) : 409 super.preferredSize(); 410 } 411 } 412 413 /** 414 * Gets the preferred size of this text field. 415 * @return the preferred dimensions for 416 * displaying this text field. 417 * @since 1.1 418 */ 419 public Dimension getPreferredSize() { 420 return preferredSize(); 421 } 422 423 /** 424 * @deprecated As of JDK version 1.1, 425 * replaced by <code>getPreferredSize()</code>. 426 */ 427 @Deprecated 428 public Dimension preferredSize() { 429 synchronized (getTreeLock()) { 430 return (columns > 0) ? 431 preferredSize(columns) : 432 super.preferredSize(); 433 } 434 } 435 436 /** 437 * Gets the minimum dimensions for a text field with 438 * the specified number of columns. 439 * @param columns the number of columns in 440 * this text field. 441 * @return the minimum size for this text field 442 * @since 1.1 443 */ 444 public Dimension getMinimumSize(int columns) { 445 return minimumSize(columns); 446 } 447 448 /** 449 * Returns the minimum dimensions for a text field with 450 * the specified number of columns. 451 * 452 * @param columns the number of columns 453 * @return the minimum size for this text field 454 * @deprecated As of JDK version 1.1, 455 * replaced by <code>getMinimumSize(int)</code>. 456 */ 457 @Deprecated 458 public Dimension minimumSize(int columns) { 459 synchronized (getTreeLock()) { 460 TextFieldPeer peer = (TextFieldPeer)this.peer; 461 return (peer != null) ? 462 peer.getMinimumSize(columns) : 463 super.minimumSize(); 464 } 465 } 466 467 /** 468 * Gets the minimum dimensions for this text field. 469 * @return the minimum dimensions for 470 * displaying this text field. 471 * @since 1.1 472 */ 473 public Dimension getMinimumSize() { 474 return minimumSize(); 475 } 476 477 /** 478 * @deprecated As of JDK version 1.1, 479 * replaced by <code>getMinimumSize()</code>. 480 */ 481 @Deprecated 482 public Dimension minimumSize() { 483 synchronized (getTreeLock()) { 484 return (columns > 0) ? 485 minimumSize(columns) : 486 super.minimumSize(); 487 } 488 } 489 490 /** 491 * Adds the specified action listener to receive 492 * action events from this text field. 493 * If l is null, no exception is thrown and no action is performed. 494 * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" 495 * >AWT Threading Issues</a> for details on AWT's threading model. 496 * 497 * @param l the action listener. 498 * @see #removeActionListener 499 * @see #getActionListeners 500 * @see java.awt.event.ActionListener 501 * @since 1.1 502 */ 503 public synchronized void addActionListener(ActionListener l) { 504 if (l == null) { 505 return; 506 } 507 actionListener = AWTEventMulticaster.add(actionListener, l); 508 newEventsOnly = true; 509 } 510 511 /** 512 * Removes the specified action listener so that it no longer 513 * receives action events from this text field. 514 * If l is null, no exception is thrown and no action is performed. 515 * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" 516 * >AWT Threading Issues</a> for details on AWT's threading model. 517 * 518 * @param l the action listener. 519 * @see #addActionListener 520 * @see #getActionListeners 521 * @see java.awt.event.ActionListener 522 * @since 1.1 523 */ 524 public synchronized void removeActionListener(ActionListener l) { 525 if (l == null) { 526 return; 527 } 528 actionListener = AWTEventMulticaster.remove(actionListener, l); 529 } 530 531 /** 532 * Returns an array of all the action listeners 533 * registered on this textfield. 534 * 535 * @return all of this textfield's <code>ActionListener</code>s 536 * or an empty array if no action 537 * listeners are currently registered 538 * 539 * @see #addActionListener 540 * @see #removeActionListener 541 * @see java.awt.event.ActionListener 542 * @since 1.4 543 */ 544 public synchronized ActionListener[] getActionListeners() { 545 return getListeners(ActionListener.class); 546 } 547 548 /** 549 * Returns an array of all the objects currently registered 550 * as <code><em>Foo</em>Listener</code>s 551 * upon this <code>TextField</code>. 552 * <code><em>Foo</em>Listener</code>s are registered using the 553 * <code>add<em>Foo</em>Listener</code> method. 554 * 555 * <p> 556 * You can specify the <code>listenerType</code> argument 557 * with a class literal, such as 558 * <code><em>Foo</em>Listener.class</code>. 559 * For example, you can query a 560 * <code>TextField</code> <code>t</code> 561 * for its action listeners with the following code: 562 * 563 * <pre>ActionListener[] als = (ActionListener[])(t.getListeners(ActionListener.class));</pre> 564 * 565 * If no such listeners exist, this method returns an empty array. 566 * 567 * @param listenerType the type of listeners requested; this parameter 568 * should specify an interface that descends from 569 * <code>java.util.EventListener</code> 570 * @return an array of all objects registered as 571 * <code><em>Foo</em>Listener</code>s on this textfield, 572 * or an empty array if no such 573 * listeners have been added 574 * @exception ClassCastException if <code>listenerType</code> 575 * doesn't specify a class or interface that implements 576 * <code>java.util.EventListener</code> 577 * 578 * @see #getActionListeners 579 * @since 1.3 580 */ 581 public <T extends EventListener> T[] getListeners(Class<T> listenerType) { 582 EventListener l = null; 583 if (listenerType == ActionListener.class) { 584 l = actionListener; 585 } else { 586 return super.getListeners(listenerType); 587 } 588 return AWTEventMulticaster.getListeners(l, listenerType); 589 } 590 591 // REMIND: remove when filtering is done at lower level 592 boolean eventEnabled(AWTEvent e) { 593 if (e.id == ActionEvent.ACTION_PERFORMED) { 594 if ((eventMask & AWTEvent.ACTION_EVENT_MASK) != 0 || 595 actionListener != null) { 596 return true; 597 } 598 return false; 599 } 600 return super.eventEnabled(e); 601 } 602 603 /** 604 * Processes events on this text field. If the event 605 * is an instance of <code>ActionEvent</code>, 606 * it invokes the <code>processActionEvent</code> 607 * method. Otherwise, it invokes <code>processEvent</code> 608 * on the superclass. 609 * <p>Note that if the event parameter is <code>null</code> 610 * the behavior is unspecified and may result in an 611 * exception. 612 * 613 * @param e the event 614 * @see java.awt.event.ActionEvent 615 * @see java.awt.TextField#processActionEvent 616 * @since 1.1 617 */ 618 protected void processEvent(AWTEvent e) { 619 if (e instanceof ActionEvent) { 620 processActionEvent((ActionEvent)e); 621 return; 622 } 623 super.processEvent(e); 624 } 625 626 /** 627 * Processes action events occurring on this text field by 628 * dispatching them to any registered 629 * <code>ActionListener</code> objects. 630 * <p> 631 * This method is not called unless action events are 632 * enabled for this component. Action events are enabled 633 * when one of the following occurs: 634 * <ul> 635 * <li>An <code>ActionListener</code> object is registered 636 * via <code>addActionListener</code>. 637 * <li>Action events are enabled via <code>enableEvents</code>. 638 * </ul> 639 * <p>Note that if the event parameter is <code>null</code> 640 * the behavior is unspecified and may result in an 641 * exception. 642 * 643 * @param e the action event 644 * @see java.awt.event.ActionListener 645 * @see java.awt.TextField#addActionListener 646 * @see java.awt.Component#enableEvents 647 * @since 1.1 648 */ 649 protected void processActionEvent(ActionEvent e) { 650 ActionListener listener = actionListener; 651 if (listener != null) { 652 listener.actionPerformed(e); 653 } 654 } 655 656 /** 657 * Returns a string representing the state of this <code>TextField</code>. 658 * This method is intended to be used only for debugging purposes, and the 659 * content and format of the returned string may vary between 660 * implementations. The returned string may be empty but may not be 661 * <code>null</code>. 662 * 663 * @return the parameter string of this text field 664 */ 665 protected String paramString() { 666 String str = super.paramString(); 667 if (echoChar != 0) { 668 str += ",echo=" + echoChar; 669 } 670 return str; 671 } 672 673 674 /* 675 * Serialization support. 676 */ 677 /** 678 * The textField Serialized Data Version. 679 * 680 * @serial 681 */ 682 private int textFieldSerializedDataVersion = 1; 683 684 /** 685 * Writes default serializable fields to stream. Writes 686 * a list of serializable ActionListener(s) as optional data. 687 * The non-serializable ActionListener(s) are detected and 688 * no attempt is made to serialize them. 689 * 690 * @serialData Null terminated sequence of zero or more pairs. 691 * A pair consists of a String and Object. 692 * The String indicates the type of object and 693 * is one of the following : 694 * ActionListenerK indicating and ActionListener object. 695 * 696 * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener) 697 * @see java.awt.Component#actionListenerK 698 */ 699 private void writeObject(ObjectOutputStream s) 700 throws IOException 701 { 702 s.defaultWriteObject(); 703 704 AWTEventMulticaster.save(s, actionListenerK, actionListener); 705 s.writeObject(null); 706 } 707 708 /** 709 * Read the ObjectInputStream and if it isn't null, 710 * add a listener to receive action events fired by the 711 * TextField. Unrecognized keys or values will be 712 * ignored. 713 * 714 * @exception HeadlessException if 715 * <code>GraphicsEnvironment.isHeadless()</code> returns 716 * <code>true</code> 717 * @see #removeActionListener(ActionListener) 718 * @see #addActionListener(ActionListener) 719 * @see java.awt.GraphicsEnvironment#isHeadless 720 */ 721 private void readObject(ObjectInputStream s) 722 throws ClassNotFoundException, IOException, HeadlessException 723 { 724 // HeadlessException will be thrown by TextComponent's readObject 725 s.defaultReadObject(); 726 text = replaceEOL(text); 727 728 // Make sure the state we just read in for columns has legal values 729 if (columns < 0) { 730 columns = 0; 731 } 732 733 // Read in listeners, if any 734 Object keyOrNull; 735 while(null != (keyOrNull = s.readObject())) { 736 String key = ((String)keyOrNull).intern(); 737 738 if (actionListenerK == key) { 739 addActionListener((ActionListener)(s.readObject())); 740 } else { 741 // skip value for unrecognized key 742 s.readObject(); 743 } 744 } 745 } 746 747 748 ///////////////// 749 // Accessibility support 750 //////////////// 751 752 753 /** 754 * Gets the AccessibleContext associated with this TextField. 755 * For text fields, the AccessibleContext takes the form of an 756 * AccessibleAWTTextField. 757 * A new AccessibleAWTTextField instance is created if necessary. 758 * 759 * @return an AccessibleAWTTextField that serves as the 760 * AccessibleContext of this TextField 761 * @since 1.3 762 */ 763 public AccessibleContext getAccessibleContext() { 764 if (accessibleContext == null) { 765 accessibleContext = new AccessibleAWTTextField(); 766 } 767 return accessibleContext; 768 } 769 770 /** 771 * This class implements accessibility support for the 772 * <code>TextField</code> class. It provides an implementation of the 773 * Java Accessibility API appropriate to text field user-interface elements. 774 * @since 1.3 775 */ 776 protected class AccessibleAWTTextField extends AccessibleAWTTextComponent 777 { 778 /* 779 * JDK 1.3 serialVersionUID 780 */ 781 private static final long serialVersionUID = 6219164359235943158L; 782 783 /** 784 * Gets the state set of this object. 785 * 786 * @return an instance of AccessibleStateSet describing the states 787 * of the object 788 * @see AccessibleState 789 */ 790 public AccessibleStateSet getAccessibleStateSet() { 791 AccessibleStateSet states = super.getAccessibleStateSet(); 792 states.add(AccessibleState.SINGLE_LINE); 793 return states; 794 } 795 } 796 797 }