Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JRE 8 rt.jar - java.* Package Source Code
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime environment included in JDK 8. JRE 8 rt.jar libraries are divided into 6 packages:
com.* - Internal Oracle and Sun Microsystems libraries java.* - Standard Java API libraries. javax.* - Extended Java API libraries. jdk.* - JDK supporting libraries. org.* - Third party libraries. sun.* - Old libraries developed by Sun Microsystems.
JAR File Information:
Directory of C:\fyicenter\jdk-1.8.0_191\jre\lib 63,596,151 rt.jar
Here is the list of Java classes of the java.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ java/awt/TextComponent.java
/* * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.awt; import java.awt.peer.TextComponentPeer; import java.awt.event.*; import java.util.EventListener; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.io.IOException; import sun.awt.InputMethodSupport; import java.text.BreakIterator; import javax.swing.text.AttributeSet; import javax.accessibility.*; import java.awt.im.InputMethodRequests; import sun.security.util.SecurityConstants; /** * The <code>TextComponent</code> class is the superclass of * any component that allows the editing of some text. * <p> * A text component embodies a string of text. The * <code>TextComponent</code> class defines a set of methods * that determine whether or not this text is editable. If the * component is editable, it defines another set of methods * that supports a text insertion caret. * <p> * In addition, the class defines methods that are used * to maintain a current <em>selection</em> from the text. * The text selection, a substring of the component's text, * is the target of editing operations. It is also referred * to as the <em>selected text</em>. * * @author Sami Shaio * @author Arthur van Hoff * @since JDK1.0 */ public class TextComponent extends Component implements Accessible { /** * The value of the text. * A <code>null</code> value is the same as "". * * @serial * @see #setText(String) * @see #getText() */ String text; /** * A boolean indicating whether or not this * <code>TextComponent</code> is editable. * It will be <code>true</code> if the text component * is editable and <code>false</code> if not. * * @serial * @see #isEditable() */ boolean editable = true; /** * The selection refers to the selected text, and the * <code>selectionStart</code> is the start position * of the selected text. * * @serial * @see #getSelectionStart() * @see #setSelectionStart(int) */ int selectionStart; /** * The selection refers to the selected text, and the * <code>selectionEnd</code> * is the end position of the selected text. * * @serial * @see #getSelectionEnd() * @see #setSelectionEnd(int) */ int selectionEnd; // A flag used to tell whether the background has been set by // developer code (as opposed to AWT code). Used to determine // the background color of non-editable TextComponents. boolean backgroundSetByClientCode = false; transient protected TextListener textListener; /* * JDK 1.1 serialVersionUID */ private static final long serialVersionUID = -2214773872412987419L; /** * Constructs a new text component initialized with the * specified text. Sets the value of the cursor to * <code>Cursor.TEXT_CURSOR</code>. * @param text the text to be displayed; if * <code>text</code> is <code>null</code>, the empty * string <code>""</code> will be displayed * @exception HeadlessException if * <code>GraphicsEnvironment.isHeadless</code> * returns true * @see java.awt.GraphicsEnvironment#isHeadless * @see java.awt.Cursor */ TextComponent(String text) throws HeadlessException { GraphicsEnvironment.checkHeadless(); this.text = (text != null) ? text : ""; setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR)); } private void enableInputMethodsIfNecessary() { if (checkForEnableIM) { checkForEnableIM = false; try { Toolkit toolkit = Toolkit.getDefaultToolkit(); boolean shouldEnable = false; if (toolkit instanceof InputMethodSupport) { shouldEnable = ((InputMethodSupport)toolkit) .enableInputMethodsForTextComponent(); } enableInputMethods(shouldEnable); } catch (Exception e) { // if something bad happens, just don't enable input methods } } } /** * Enables or disables input method support for this text component. If input * method support is enabled and the text component also processes key events, * incoming events are offered to the current input method and will only be * processed by the component or dispatched to its listeners if the input method * does not consume them. Whether and how input method support for this text * component is enabled or disabled by default is implementation dependent. * * @param enable true to enable, false to disable * @see #processKeyEvent * @since 1.2 */ public void enableInputMethods(boolean enable) { checkForEnableIM = false; super.enableInputMethods(enable); } boolean areInputMethodsEnabled() { // moved from the constructor above to here and addNotify below, // this call will initialize the toolkit if not already initialized. if (checkForEnableIM) { enableInputMethodsIfNecessary(); } // TextComponent handles key events without touching the eventMask or // having a key listener, so just check whether the flag is set return (eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0; } public InputMethodRequests getInputMethodRequests() { TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) return peer.getInputMethodRequests(); else return null; } /** * Makes this Component displayable by connecting it to a * native screen resource. * This method is called internally by the toolkit and should * not be called directly by programs. * @see java.awt.TextComponent#removeNotify */ public void addNotify() { super.addNotify(); enableInputMethodsIfNecessary(); } /** * Removes the <code>TextComponent</code>'s peer. * The peer allows us to modify the appearance of the * <code>TextComponent</code> without changing its * functionality. */ public void removeNotify() { synchronized (getTreeLock()) { TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { text = peer.getText(); selectionStart = peer.getSelectionStart(); selectionEnd = peer.getSelectionEnd(); } super.removeNotify(); } } /** * Sets the text that is presented by this * text component to be the specified text. * @param t the new text; * if this parameter is <code>null</code> then * the text is set to the empty string "" * @see java.awt.TextComponent#getText */ public synchronized void setText(String t) { boolean skipTextEvent = (text == null || text.isEmpty()) && (t == null || t.isEmpty()); text = (t != null) ? t : ""; TextComponentPeer peer = (TextComponentPeer)this.peer; // Please note that we do not want to post an event // if TextArea.setText() or TextField.setText() replaces an empty text // by an empty text, that is, if component's text remains unchanged. if (peer != null && !skipTextEvent) { peer.setText(text); } } /** * Returns the text that is presented by this text component. * By default, this is an empty string. * * @return the value of this <code>TextComponent</code> * @see java.awt.TextComponent#setText */ public synchronized String getText() { TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { text = peer.getText(); } return text; } /** * Returns the selected text from the text that is * presented by this text component. * @return the selected text of this text component * @see java.awt.TextComponent#select */ public synchronized String getSelectedText() { return getText().substring(getSelectionStart(), getSelectionEnd()); } /** * Indicates whether or not this text component is editable. * @return <code>true</code> if this text component is * editable; <code>false</code> otherwise. * @see java.awt.TextComponent#setEditable * @since JDK1.0 */ public boolean isEditable() { return editable; } /** * Sets the flag that determines whether or not this * text component is editable. * <p> * If the flag is set to <code>true</code>, this text component * becomes user editable. If the flag is set to <code>false</code>, * the user cannot change the text of this text component. * By default, non-editable text components have a background color * of SystemColor.control. This default can be overridden by * calling setBackground. * * @param b a flag indicating whether this text component * is user editable. * @see java.awt.TextComponent#isEditable * @since JDK1.0 */ public synchronized void setEditable(boolean b) { if (editable == b) { return; } editable = b; TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { peer.setEditable(b); } } /** * Gets the background color of this text component. * * By default, non-editable text components have a background color * of SystemColor.control. This default can be overridden by * calling setBackground. * * @return This text component's background color. * If this text component does not have a background color, * the background color of its parent is returned. * @see #setBackground(Color) * @since JDK1.0 */ public Color getBackground() { if (!editable && !backgroundSetByClientCode) { return SystemColor.control; } return super.getBackground(); } /** * Sets the background color of this text component. * * @param c The color to become this text component's color. * If this parameter is null then this text component * will inherit the background color of its parent. * @see #getBackground() * @since JDK1.0 */ public void setBackground(Color c) { backgroundSetByClientCode = true; super.setBackground(c); } /** * Gets the start position of the selected text in * this text component. * @return the start position of the selected text * @see java.awt.TextComponent#setSelectionStart * @see java.awt.TextComponent#getSelectionEnd */ public synchronized int getSelectionStart() { TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { selectionStart = peer.getSelectionStart(); } return selectionStart; } /** * Sets the selection start for this text component to * the specified position. The new start point is constrained * to be at or before the current selection end. It also * cannot be set to less than zero, the beginning of the * component's text. * If the caller supplies a value for <code>selectionStart</code> * that is out of bounds, the method enforces these constraints * silently, and without failure. * @param selectionStart the start position of the * selected text * @see java.awt.TextComponent#getSelectionStart * @see java.awt.TextComponent#setSelectionEnd * @since JDK1.1 */ public synchronized void setSelectionStart(int selectionStart) { /* Route through select method to enforce consistent policy * between selectionStart and selectionEnd. */ select(selectionStart, getSelectionEnd()); } /** * Gets the end position of the selected text in * this text component. * @return the end position of the selected text * @see java.awt.TextComponent#setSelectionEnd * @see java.awt.TextComponent#getSelectionStart */ public synchronized int getSelectionEnd() { TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { selectionEnd = peer.getSelectionEnd(); } return selectionEnd; } /** * Sets the selection end for this text component to * the specified position. The new end point is constrained * to be at or after the current selection start. It also * cannot be set beyond the end of the component's text. * If the caller supplies a value for <code>selectionEnd</code> * that is out of bounds, the method enforces these constraints * silently, and without failure. * @param selectionEnd the end position of the * selected text * @see java.awt.TextComponent#getSelectionEnd * @see java.awt.TextComponent#setSelectionStart * @since JDK1.1 */ public synchronized void setSelectionEnd(int selectionEnd) { /* Route through select method to enforce consistent policy * between selectionStart and selectionEnd. */ select(getSelectionStart(), selectionEnd); } /** * Selects the text between the specified start and end positions. * <p> * This method sets the start and end positions of the * selected text, enforcing the restriction that the start position * must be greater than or equal to zero. The end position must be * greater than or equal to the start position, and less than or * equal to the length of the text component's text. The * character positions are indexed starting with zero. * The length of the selection is * <code>endPosition</code> - <code>startPosition</code>, so the * character at <code>endPosition</code> is not selected. * If the start and end positions of the selected text are equal, * all text is deselected. * <p> * If the caller supplies values that are inconsistent or out of * bounds, the method enforces these constraints silently, and * without failure. Specifically, if the start position or end * position is greater than the length of the text, it is reset to * equal the text length. If the start position is less than zero, * it is reset to zero, and if the end position is less than the * start position, it is reset to the start position. * * @param selectionStart the zero-based index of the first character (<code>char</code> value) to be selected * @param selectionEnd the zero-based end position of the text to be selected; the character (<code>char</code> value) at <code>selectionEnd</code> is not selected * @see java.awt.TextComponent#setSelectionStart * @see java.awt.TextComponent#setSelectionEnd * @see java.awt.TextComponent#selectAll */ public synchronized void select(int selectionStart, int selectionEnd) { String text = getText(); if (selectionStart < 0) { selectionStart = 0; } if (selectionStart > text.length()) { selectionStart = text.length(); } if (selectionEnd > text.length()) { selectionEnd = text.length(); } if (selectionEnd < selectionStart) { selectionEnd = selectionStart; } this.selectionStart = selectionStart; this.selectionEnd = selectionEnd; TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { peer.select(selectionStart, selectionEnd); } } /** * Selects all the text in this text component. * @see java.awt.TextComponent#select */ public synchronized void selectAll() { this.selectionStart = 0; this.selectionEnd = getText().length(); TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { peer.select(selectionStart, selectionEnd); } } /** * Sets the position of the text insertion caret. * The caret position is constrained to be between 0 * and the last character of the text, inclusive. * If the passed-in value is greater than this range, * the value is set to the last character (or 0 if * the <code>TextComponent</code> contains no text) * and no error is returned. If the passed-in value is * less than 0, an <code>IllegalArgumentException</code> * is thrown. * * @param position the position of the text insertion caret * @exception IllegalArgumentException if <code>position</code> * is less than zero * @since JDK1.1 */ public synchronized void setCaretPosition(int position) { if (position < 0) { throw new IllegalArgumentException("position less than zero."); } int maxposition = getText().length(); if (position > maxposition) { position = maxposition; } TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { peer.setCaretPosition(position); } else { select(position, position); } } /** * Returns the position of the text insertion caret. * The caret position is constrained to be between 0 * and the last character of the text, inclusive. * If the text or caret have not been set, the default * caret position is 0. * * @return the position of the text insertion caret * @see #setCaretPosition(int) * @since JDK1.1 */ public synchronized int getCaretPosition() { TextComponentPeer peer = (TextComponentPeer)this.peer; int position = 0; if (peer != null) { position = peer.getCaretPosition(); } else { position = selectionStart; } int maxposition = getText().length(); if (position > maxposition) { position = maxposition; } return position; } /** * Adds the specified text event listener to receive text events * from this text component. * If <code>l</code> is <code>null</code>, no exception is * thrown and no action is performed. * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" * >AWT Threading Issues</a> for details on AWT's threading model. * * @param l the text event listener * @see #removeTextListener * @see #getTextListeners * @see java.awt.event.TextListener */ public synchronized void addTextListener(TextListener l) { if (l == null) { return; } textListener = AWTEventMulticaster.add(textListener, l); newEventsOnly = true; } /** * Removes the specified text event listener so that it no longer * receives text events from this text component * If <code>l</code> is <code>null</code>, no exception is * thrown and no action is performed. * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads" * >AWT Threading Issues</a> for details on AWT's threading model. * * @param l the text listener * @see #addTextListener * @see #getTextListeners * @see java.awt.event.TextListener * @since JDK1.1 */ public synchronized void removeTextListener(TextListener l) { if (l == null) { return; } textListener = AWTEventMulticaster.remove(textListener, l); } /** * Returns an array of all the text listeners * registered on this text component. * * @return all of this text component's <code>TextListener</code>s * or an empty array if no text * listeners are currently registered * * * @see #addTextListener * @see #removeTextListener * @since 1.4 */ public synchronized TextListener[] getTextListeners() { return getListeners(TextListener.class); } /** * Returns an array of all the objects currently registered * as <code><em>Foo</em>Listener</code>s * upon this <code>TextComponent</code>. * <code><em>Foo</em>Listener</code>s are registered using the * <code>add<em>Foo</em>Listener</code> method. * * <p> * You can specify the <code>listenerType</code> argument * with a class literal, such as * <code><em>Foo</em>Listener.class</code>. * For example, you can query a * <code>TextComponent</code> <code>t</code> * for its text listeners with the following code: * * <pre>TextListener[] tls = (TextListener[])(t.getListeners(TextListener.class));</pre> * * If no such listeners exist, this method returns an empty array. * * @param listenerType the type of listeners requested; this parameter * should specify an interface that descends from * <code>java.util.EventListener</code> * @return an array of all objects registered as * <code><em>Foo</em>Listener</code>s on this text component, * or an empty array if no such * listeners have been added * @exception ClassCastException if <code>listenerType</code> * doesn't specify a class or interface that implements * <code>java.util.EventListener</code> * * @see #getTextListeners * @since 1.3 */ public <T extends EventListener> T[] getListeners(Class<T> listenerType) { EventListener l = null; if (listenerType == TextListener.class) { l = textListener; } else { return super.getListeners(listenerType); } return AWTEventMulticaster.getListeners(l, listenerType); } // REMIND: remove when filtering is done at lower level boolean eventEnabled(AWTEvent e) { if (e.id == TextEvent.TEXT_VALUE_CHANGED) { if ((eventMask & AWTEvent.TEXT_EVENT_MASK) != 0 || textListener != null) { return true; } return false; } return super.eventEnabled(e); } /** * Processes events on this text component. If the event is a * <code>TextEvent</code>, it invokes the <code>processTextEvent</code> * method else it invokes its superclass's <code>processEvent</code>. * <p>Note that if the event parameter is <code>null</code> * the behavior is unspecified and may result in an * exception. * * @param e the event */ protected void processEvent(AWTEvent e) { if (e instanceof TextEvent) { processTextEvent((TextEvent)e); return; } super.processEvent(e); } /** * Processes text events occurring on this text component by * dispatching them to any registered <code>TextListener</code> objects. * <p> * NOTE: This method will not be called unless text events * are enabled for this component. This happens when one of the * following occurs: * <ul> * <li>A <code>TextListener</code> object is registered * via <code>addTextListener</code> * <li>Text events are enabled via <code>enableEvents</code> * </ul> * <p>Note that if the event parameter is <code>null</code> * the behavior is unspecified and may result in an * exception. * * @param e the text event * @see Component#enableEvents */ protected void processTextEvent(TextEvent e) { TextListener listener = textListener; if (listener != null) { int id = e.getID(); switch (id) { case TextEvent.TEXT_VALUE_CHANGED: listener.textValueChanged(e); break; } } } /** * Returns a string representing the state of this * <code>TextComponent</code>. This * method is intended to be used only for debugging purposes, and the * content and format of the returned string may vary between * implementations. The returned string may be empty but may not be * <code>null</code>. * * @return the parameter string of this text component */ protected String paramString() { String str = super.paramString() + ",text=" + getText(); if (editable) { str += ",editable"; } return str + ",selection=" + getSelectionStart() + "-" + getSelectionEnd(); } /** * Assigns a valid value to the canAccessClipboard instance variable. */ private boolean canAccessClipboard() { SecurityManager sm = System.getSecurityManager(); if (sm == null) return true; try { sm.checkPermission(SecurityConstants.AWT.ACCESS_CLIPBOARD_PERMISSION); return true; } catch (SecurityException e) {} return false; } /* * Serialization support. */ /** * The textComponent SerializedDataVersion. * * @serial */ private int textComponentSerializedDataVersion = 1; /** * Writes default serializable fields to stream. Writes * a list of serializable TextListener(s) as optional data. * The non-serializable TextListener(s) are detected and * no attempt is made to serialize them. * * @serialData Null terminated sequence of zero or more pairs. * A pair consists of a String and Object. * The String indicates the type of object and * is one of the following : * textListenerK indicating and TextListener object. * * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener) * @see java.awt.Component#textListenerK */ private void writeObject(java.io.ObjectOutputStream s) throws IOException { // Serialization support. Since the value of the fields // selectionStart, selectionEnd, and text aren't necessarily // up to date, we sync them up with the peer before serializing. TextComponentPeer peer = (TextComponentPeer)this.peer; if (peer != null) { text = peer.getText(); selectionStart = peer.getSelectionStart(); selectionEnd = peer.getSelectionEnd(); } s.defaultWriteObject(); AWTEventMulticaster.save(s, textListenerK, textListener); s.writeObject(null); } /** * Read the ObjectInputStream, and if it isn't null, * add a listener to receive text events fired by the * TextComponent. Unrecognized keys or values will be * ignored. * * @exception HeadlessException if * <code>GraphicsEnvironment.isHeadless()</code> returns * <code>true</code> * @see #removeTextListener * @see #addTextListener * @see java.awt.GraphicsEnvironment#isHeadless */ private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException { GraphicsEnvironment.checkHeadless(); s.defaultReadObject(); // Make sure the state we just read in for text, // selectionStart and selectionEnd has legal values this.text = (text != null) ? text : ""; select(selectionStart, selectionEnd); Object keyOrNull; while(null != (keyOrNull = s.readObject())) { String key = ((String)keyOrNull).intern(); if (textListenerK == key) { addTextListener((TextListener)(s.readObject())); } else { // skip value for unrecognized key s.readObject(); } } enableInputMethodsIfNecessary(); } ///////////////// // Accessibility support //////////////// /** * Gets the AccessibleContext associated with this TextComponent. * For text components, the AccessibleContext takes the form of an * AccessibleAWTTextComponent. * A new AccessibleAWTTextComponent instance is created if necessary. * * @return an AccessibleAWTTextComponent that serves as the * AccessibleContext of this TextComponent * @since 1.3 */ public AccessibleContext getAccessibleContext() { if (accessibleContext == null) { accessibleContext = new AccessibleAWTTextComponent(); } return accessibleContext; } /** * This class implements accessibility support for the * <code>TextComponent</code> class. It provides an implementation of the * Java Accessibility API appropriate to text component user-interface * elements. * @since 1.3 */ protected class AccessibleAWTTextComponent extends AccessibleAWTComponent implements AccessibleText, TextListener { /* * JDK 1.3 serialVersionUID */ private static final long serialVersionUID = 3631432373506317811L; /** * Constructs an AccessibleAWTTextComponent. Adds a listener to track * caret change. */ public AccessibleAWTTextComponent() { TextComponent.this.addTextListener(this); } /** * TextListener notification of a text value change. */ public void textValueChanged(TextEvent textEvent) { Integer cpos = Integer.valueOf(TextComponent.this.getCaretPosition()); firePropertyChange(ACCESSIBLE_TEXT_PROPERTY, null, cpos); } /** * Gets the state set of the TextComponent. * The AccessibleStateSet of an object is composed of a set of * unique AccessibleStates. A change in the AccessibleStateSet * of an object will cause a PropertyChangeEvent to be fired * for the AccessibleContext.ACCESSIBLE_STATE_PROPERTY property. * * @return an instance of AccessibleStateSet containing the * current state set of the object * @see AccessibleStateSet * @see AccessibleState * @see #addPropertyChangeListener */ public AccessibleStateSet getAccessibleStateSet() { AccessibleStateSet states = super.getAccessibleStateSet(); if (TextComponent.this.isEditable()) { states.add(AccessibleState.EDITABLE); } return states; } /** * Gets the role of this object. * * @return an instance of AccessibleRole describing the role of the * object (AccessibleRole.TEXT) * @see AccessibleRole */ public AccessibleRole getAccessibleRole() { return AccessibleRole.TEXT; } /** * Get the AccessibleText associated with this object. In the * implementation of the Java Accessibility API for this class, * return this object, which is responsible for implementing the * AccessibleText interface on behalf of itself. * * @return this object */ public AccessibleText getAccessibleText() { return this; } // --- interface AccessibleText methods ------------------------ /** * Many of these methods are just convenience methods; they * just call the equivalent on the parent */ /** * Given a point in local coordinates, return the zero-based index * of the character under that Point. If the point is invalid, * this method returns -1. * * @param p the Point in local coordinates * @return the zero-based index of the character under Point p. */ public int getIndexAtPoint(Point p) { return -1; } /** * Determines the bounding box of the character at the given * index into the string. The bounds are returned in local * coordinates. If the index is invalid a null rectangle * is returned. * * @param i the index into the String >= 0 * @return the screen coordinates of the character's bounding box */ public Rectangle getCharacterBounds(int i) { return null; } /** * Returns the number of characters (valid indicies) * * @return the number of characters >= 0 */ public int getCharCount() { return TextComponent.this.getText().length(); } /** * Returns the zero-based offset of the caret. * * Note: The character to the right of the caret will have the * same index value as the offset (the caret is between * two characters). * * @return the zero-based offset of the caret. */ public int getCaretPosition() { return TextComponent.this.getCaretPosition(); } /** * Returns the AttributeSet for a given character (at a given index). * * @param i the zero-based index into the text * @return the AttributeSet of the character */ public AttributeSet getCharacterAttribute(int i) { return null; // No attributes in TextComponent } /** * Returns the start offset within the selected text. * If there is no selection, but there is * a caret, the start and end offsets will be the same. * Return 0 if the text is empty, or the caret position * if no selection. * * @return the index into the text of the start of the selection >= 0 */ public int getSelectionStart() { return TextComponent.this.getSelectionStart(); } /** * Returns the end offset within the selected text. * If there is no selection, but there is * a caret, the start and end offsets will be the same. * Return 0 if the text is empty, or the caret position * if no selection. * * @return the index into the text of the end of the selection >= 0 */ public int getSelectionEnd() { return TextComponent.this.getSelectionEnd(); } /** * Returns the portion of the text that is selected. * * @return the text, null if no selection */ public String getSelectedText() { String selText = TextComponent.this.getSelectedText(); // Fix for 4256662 if (selText == null || selText.equals("")) { return null; } return selText; } /** * Returns the String at a given index. * * @param part the AccessibleText.CHARACTER, AccessibleText.WORD, * or AccessibleText.SENTENCE to retrieve * @param index an index within the text >= 0 * @return the letter, word, or sentence, * null for an invalid index or part */ public String getAtIndex(int part, int index) { if (index < 0 || index >= TextComponent.this.getText().length()) { return null; } switch (part) { case AccessibleText.CHARACTER: return TextComponent.this.getText().substring(index, index+1); case AccessibleText.WORD: { String s = TextComponent.this.getText(); BreakIterator words = BreakIterator.getWordInstance(); words.setText(s); int end = words.following(index); return s.substring(words.previous(), end); } case AccessibleText.SENTENCE: { String s = TextComponent.this.getText(); BreakIterator sentence = BreakIterator.getSentenceInstance(); sentence.setText(s); int end = sentence.following(index); return s.substring(sentence.previous(), end); } default: return null; } } private static final boolean NEXT = true; private static final boolean PREVIOUS = false; /** * Needed to unify forward and backward searching. * The method assumes that s is the text assigned to words. */ private int findWordLimit(int index, BreakIterator words, boolean direction, String s) { // Fix for 4256660 and 4256661. // Words iterator is different from character and sentence iterators // in that end of one word is not necessarily start of another word. // Please see java.text.BreakIterator JavaDoc. The code below is // based on nextWordStartAfter example from BreakIterator.java. int last = (direction == NEXT) ? words.following(index) : words.preceding(index); int current = (direction == NEXT) ? words.next() : words.previous(); while (current != BreakIterator.DONE) { for (int p = Math.min(last, current); p < Math.max(last, current); p++) { if (Character.isLetter(s.charAt(p))) { return last; } } last = current; current = (direction == NEXT) ? words.next() : words.previous(); } return BreakIterator.DONE; } /** * Returns the String after a given index. * * @param part the AccessibleText.CHARACTER, AccessibleText.WORD, * or AccessibleText.SENTENCE to retrieve * @param index an index within the text >= 0 * @return the letter, word, or sentence, null for an invalid * index or part */ public String getAfterIndex(int part, int index) { if (index < 0 || index >= TextComponent.this.getText().length()) { return null; } switch (part) { case AccessibleText.CHARACTER: if (index+1 >= TextComponent.this.getText().length()) { return null; } return TextComponent.this.getText().substring(index+1, index+2); case AccessibleText.WORD: { String s = TextComponent.this.getText(); BreakIterator words = BreakIterator.getWordInstance(); words.setText(s); int start = findWordLimit(index, words, NEXT, s); if (start == BreakIterator.DONE || start >= s.length()) { return null; } int end = words.following(start); if (end == BreakIterator.DONE || end >= s.length()) { return null; } return s.substring(start, end); } case AccessibleText.SENTENCE: { String s = TextComponent.this.getText(); BreakIterator sentence = BreakIterator.getSentenceInstance(); sentence.setText(s); int start = sentence.following(index); if (start == BreakIterator.DONE || start >= s.length()) { return null; } int end = sentence.following(start); if (end == BreakIterator.DONE || end >= s.length()) { return null; } return s.substring(start, end); } default: return null; } } /** * Returns the String before a given index. * * @param part the AccessibleText.CHARACTER, AccessibleText.WORD, * or AccessibleText.SENTENCE to retrieve * @param index an index within the text >= 0 * @return the letter, word, or sentence, null for an invalid index * or part */ public String getBeforeIndex(int part, int index) { if (index < 0 || index > TextComponent.this.getText().length()-1) { return null; } switch (part) { case AccessibleText.CHARACTER: if (index == 0) { return null; } return TextComponent.this.getText().substring(index-1, index); case AccessibleText.WORD: { String s = TextComponent.this.getText(); BreakIterator words = BreakIterator.getWordInstance(); words.setText(s); int end = findWordLimit(index, words, PREVIOUS, s); if (end == BreakIterator.DONE) { return null; } int start = words.preceding(end); if (start == BreakIterator.DONE) { return null; } return s.substring(start, end); } case AccessibleText.SENTENCE: { String s = TextComponent.this.getText(); BreakIterator sentence = BreakIterator.getSentenceInstance(); sentence.setText(s); int end = sentence.following(index); end = sentence.previous(); int start = sentence.previous(); if (start == BreakIterator.DONE) { return null; } return s.substring(start, end); } default: return null; } } } // end of AccessibleAWTTextComponent private boolean checkForEnableIM = true; }
⏎ java/awt/TextComponent.java
Or download all of them as a single archive file:
File name: jre-rt-java-1.8.0_191-src.zip File size: 6664831 bytes Release date: 2018-10-28 Download
⇒ JRE 8 rt.jar - javax.* Package Source Code
2023-08-23, 250466👍, 4💬
Popular Posts:
JDK 11 jdk.dynalink.jmod is the JMOD file for JDK 11 Dynamic Linking module. JDK 11 Dynamic Linking ...
What JAR files are required to run sax\Writer.java provided in the Apache Xerces package? 1 JAR file...
JDK 11 jdk.rmic.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) Compiler Tool tool, ...
ZooKeeper is a centralized service for maintaining configuration information, naming, providing dist...
commons-collections4-4.4 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...