Java Code Examples for java.text.AttributedCharacterIterator#getBeginIndex()

/**
 * Draws a string of attributed characters at {@code (x, y)}. 
 * 
 * @param iterator  an iterator over the characters ({@code null} not 
 *     permitted).
 * @param x  the x-coordinate.
 * @param y  the y-coordinate.
 */
@Override
public void drawString(AttributedCharacterIterator iterator, float x, 
        float y) {
    Set<AttributedCharacterIterator.Attribute> 
            s = iterator.getAllAttributeKeys();
    if (!s.isEmpty()) {
        TextLayout layout = new TextLayout(iterator, 
                getFontRenderContext());
        layout.draw(this, x, y);
    } else {
        StringBuilder strb = new StringBuilder();
        iterator.first();
        for (int i = iterator.getBeginIndex(); i < iterator.getEndIndex(); 
                i++) {
            strb.append(iterator.current());
            iterator.next();
        }
        drawString(strb.toString(), x, y);
    }
}
 

private static AttributedCharacterIterator getTrimmedTrailingSpacesIterator
        (AttributedCharacterIterator iterator) {
    int curIdx = iterator.getIndex();

    char c = iterator.last();
    while(c != CharacterIterator.DONE && Character.isWhitespace(c)) {
        c = iterator.previous();
    }

    if (c != CharacterIterator.DONE) {
        int endIdx = iterator.getIndex();

        if (endIdx == iterator.getEndIndex() - 1) {
            iterator.setIndex(curIdx);
            return iterator;
        } else {
            AttributedString trimmedText = new AttributedString(iterator,
                    iterator.getBeginIndex(), endIdx + 1);
            return trimmedText.getIterator();
        }
    } else {
        return null;
    }
}
 

private static AttributedCharacterIterator getTrimmedTrailingSpacesIterator
        (AttributedCharacterIterator iterator) {
    int curIdx = iterator.getIndex();

    char c = iterator.last();
    while(c != CharacterIterator.DONE && Character.isWhitespace(c)) {
        c = iterator.previous();
    }

    if (c != CharacterIterator.DONE) {
        int endIdx = iterator.getIndex();

        if (endIdx == iterator.getEndIndex() - 1) {
            iterator.setIndex(curIdx);
            return iterator;
        } else {
            AttributedString trimmedText = new AttributedString(iterator,
                    iterator.getBeginIndex(), endIdx + 1);
            return trimmedText.getIterator();
        }
    } else {
        return null;
    }
}
 

/**
 * Constructs a <code>TextLayout</code> from an iterator over styled text.
 * <p>
 * The iterator must specify a single paragraph of text because an
 * entire paragraph is required for the bidirectional
 * algorithm.
 * @param text the styled text to display
 * @param frc contains information about a graphics device which is needed
 *       to measure the text correctly.
 *       Text measurements can vary slightly depending on the
 *       device resolution, and attributes such as antialiasing.  This
 *       parameter does not specify a translation between the
 *       <code>TextLayout</code> and user space.
 */
public TextLayout(AttributedCharacterIterator text, FontRenderContext frc) {

    if (text == null) {
        throw new IllegalArgumentException("Null iterator passed to TextLayout constructor.");
    }

    int start = text.getBeginIndex();
    int limit = text.getEndIndex();
    if (start == limit) {
        throw new IllegalArgumentException("Zero length iterator passed to TextLayout constructor.");
    }

    int len = limit - start;
    text.first();
    char[] chars = new char[len];
    int n = 0;
    for (char c = text.first();
         c != CharacterIterator.DONE;
         c = text.next())
    {
        chars[n++] = c;
    }

    text.first();
    if (text.getRunLimit() == limit) {

        Map<? extends Attribute, ?> attributes = text.getAttributes();
        Font font = singleFont(chars, 0, len, attributes);
        if (font != null) {
            fastInit(chars, font, attributes, frc);
            return;
        }
    }

    standardInit(text, chars, frc);
}
 

/**
 * Draws a string at the specified position.
 *
 * @param iterator  the string.
 * @param x  the x-coordinate.
 * @param y  the y-coordinate.
 */
public void drawString(AttributedCharacterIterator iterator, int x, int y) {
    // for now we simply want to extract the chars from the iterator
    // and call an unstyled text renderer
    StringBuffer sb = new StringBuffer();
    int numChars = iterator.getEndIndex() - iterator.getBeginIndex();
    char c = iterator.first();
    for (int i = 0; i < numChars; i++) {
        sb.append(c);
        c = iterator.next();
    }
    drawString(new String(sb),x,y);
}
 

/**
 * Return a StyledParagraph reflecting the insertion of a single character
 * into the text.  This method will attempt to reuse the given paragraph,
 * but may create a new paragraph.
 * @param aci an iterator over the text.  The text should be the same as the
 *     text used to create (or most recently update) oldParagraph, with
 *     the exception of deleting a single character at deletePos.
 * @param chars the characters in aci
 * @param deletePos the index where a character was removed
 * @param oldParagraph a StyledParagraph for the text in aci before the
 *     insertion
 */
public static StyledParagraph deleteChar(AttributedCharacterIterator aci,
                                         char[] chars,
                                         int deletePos,
                                         StyledParagraph oldParagraph) {

    // We will reuse oldParagraph unless there was a length-1 run
    // at deletePos.  We could do more work and check the individual
    // Font and Decoration runs, but we don't right now...
    deletePos -= aci.getBeginIndex();

    if (oldParagraph.decorations == null && oldParagraph.fonts == null) {
        oldParagraph.length -= 1;
        return oldParagraph;
    }

    if (oldParagraph.getRunLimit(deletePos) == deletePos+1) {
        if (deletePos == 0 || oldParagraph.getRunLimit(deletePos-1) == deletePos) {
            return new StyledParagraph(aci, chars);
        }
    }

    oldParagraph.length -= 1;
    if (oldParagraph.decorations != null) {
        deleteFrom(deletePos,
                   oldParagraph.decorationStarts,
                   oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
        deleteFrom(deletePos,
                   oldParagraph.fontStarts,
                   oldParagraph.fonts.size());
    }
    return oldParagraph;
}
 

/**
 * Return a StyledParagraph reflecting the insertion of a single character
 * into the text.  This method will attempt to reuse the given paragraph,
 * but may create a new paragraph.
 * @param aci an iterator over the text.  The text should be the same as the
 *     text used to create (or most recently update) oldParagraph, with
 *     the exception of deleting a single character at deletePos.
 * @param chars the characters in aci
 * @param deletePos the index where a character was removed
 * @param oldParagraph a StyledParagraph for the text in aci before the
 *     insertion
 */
public static StyledParagraph deleteChar(AttributedCharacterIterator aci,
                                         char[] chars,
                                         int deletePos,
                                         StyledParagraph oldParagraph) {

    // We will reuse oldParagraph unless there was a length-1 run
    // at deletePos.  We could do more work and check the individual
    // Font and Decoration runs, but we don't right now...
    deletePos -= aci.getBeginIndex();

    if (oldParagraph.decorations == null && oldParagraph.fonts == null) {
        oldParagraph.length -= 1;
        return oldParagraph;
    }

    if (oldParagraph.getRunLimit(deletePos) == deletePos+1) {
        if (deletePos == 0 || oldParagraph.getRunLimit(deletePos-1) == deletePos) {
            return new StyledParagraph(aci, chars);
        }
    }

    oldParagraph.length -= 1;
    if (oldParagraph.decorations != null) {
        deleteFrom(deletePos,
                   oldParagraph.decorationStarts,
                   oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
        deleteFrom(deletePos,
                   oldParagraph.fontStarts,
                   oldParagraph.fonts.size());
    }
    return oldParagraph;
}
 

public void drawString(AttributedCharacterIterator iterator,
                       int x, int y) {
    if (iterator == null) {
        throw new NullPointerException("AttributedCharacterIterator is null");
    }
    if (iterator.getBeginIndex() == iterator.getEndIndex()) {
        return; /* nothing to draw */
    }
    TextLayout tl = new TextLayout(iterator, getFontRenderContext());
    tl.draw(this, (float) x, (float) y);
}
 

/**
 * Constructs a <code>TextLayout</code> from an iterator over styled text.
 * <p>
 * The iterator must specify a single paragraph of text because an
 * entire paragraph is required for the bidirectional
 * algorithm.
 * @param text the styled text to display
 * @param frc contains information about a graphics device which is needed
 *       to measure the text correctly.
 *       Text measurements can vary slightly depending on the
 *       device resolution, and attributes such as antialiasing.  This
 *       parameter does not specify a translation between the
 *       <code>TextLayout</code> and user space.
 */
public TextLayout(AttributedCharacterIterator text, FontRenderContext frc) {

    if (text == null) {
        throw new IllegalArgumentException("Null iterator passed to TextLayout constructor.");
    }

    int start = text.getBeginIndex();
    int limit = text.getEndIndex();
    if (start == limit) {
        throw new IllegalArgumentException("Zero length iterator passed to TextLayout constructor.");
    }

    int len = limit - start;
    text.first();
    char[] chars = new char[len];
    int n = 0;
    for (char c = text.first();
         c != CharacterIterator.DONE;
         c = text.next())
    {
        chars[n++] = c;
    }

    text.first();
    if (text.getRunLimit() == limit) {

        Map<? extends Attribute, ?> attributes = text.getAttributes();
        Font font = singleFont(chars, 0, len, attributes);
        if (font != null) {
            fastInit(chars, font, attributes, frc);
            return;
        }
    }

    standardInit(text, chars, frc);
}
 

/**
 * Return a StyledParagraph reflecting the insertion of a single character
 * into the text.  This method will attempt to reuse the given paragraph,
 * but may create a new paragraph.
 * @param aci an iterator over the text.  The text should be the same as the
 *     text used to create (or most recently update) oldParagraph, with
 *     the exception of deleting a single character at deletePos.
 * @param chars the characters in aci
 * @param deletePos the index where a character was removed
 * @param oldParagraph a StyledParagraph for the text in aci before the
 *     insertion
 */
public static StyledParagraph deleteChar(AttributedCharacterIterator aci,
                                         char[] chars,
                                         int deletePos,
                                         StyledParagraph oldParagraph) {

    // We will reuse oldParagraph unless there was a length-1 run
    // at deletePos.  We could do more work and check the individual
    // Font and Decoration runs, but we don't right now...
    deletePos -= aci.getBeginIndex();

    if (oldParagraph.decorations == null && oldParagraph.fonts == null) {
        oldParagraph.length -= 1;
        return oldParagraph;
    }

    if (oldParagraph.getRunLimit(deletePos) == deletePos+1) {
        if (deletePos == 0 || oldParagraph.getRunLimit(deletePos-1) == deletePos) {
            return new StyledParagraph(aci, chars);
        }
    }

    oldParagraph.length -= 1;
    if (oldParagraph.decorations != null) {
        deleteFrom(deletePos,
                   oldParagraph.decorationStarts,
                   oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
        deleteFrom(deletePos,
                   oldParagraph.fontStarts,
                   oldParagraph.fonts.size());
    }
    return oldParagraph;
}
 

@Override
        public void inputMethodTextChanged(InputMethodEvent e) {
            int committedCharacterCount = e.getCommittedCharacterCount();
            AttributedCharacterIterator text = e.getText();
            composedText = null;
            char c;
            if (text != null) {
                if (committedCharacterCount > 0) {
                    int toCopy = committedCharacterCount;
                    c = text.first();
                    StringBuilder sb = new StringBuilder();
                    while (toCopy-- > 0) {
                        sb.append(c);
                        c = text.next();
                    }
                    inputListener.type(sb.toString());
                }

                if (text.getEndIndex()
                        - (text.getBeginIndex() + committedCharacterCount) > 0) {
                    composedTextString = new AttributedString(text, text
                            .getBeginIndex()
                            + committedCharacterCount, text.getEndIndex(),
                            IM_ATTRIBUTES);
                    composedTextString.addAttribute(TextAttribute.FONT, getFont());
                    composedText = composedTextString.getIterator();
                    //TODO The code below need be extended
//                    System.out.print(composedText.first());
//                    while (composedText.getIndex() < composedText.getEndIndex()) {
//                        System.out.print(composedText.next());
//                    }
                }
            }
            e.consume();
        }
 

/**
 * Return a StyledParagraph reflecting the insertion of a single character
 * into the text.  This method will attempt to reuse the given paragraph,
 * but may create a new paragraph.
 * @param aci an iterator over the text.  The text should be the same as the
 *     text used to create (or most recently update) oldParagraph, with
 *     the exception of deleting a single character at deletePos.
 * @param chars the characters in aci
 * @param deletePos the index where a character was removed
 * @param oldParagraph a StyledParagraph for the text in aci before the
 *     insertion
 */
public static StyledParagraph deleteChar(AttributedCharacterIterator aci,
                                         char[] chars,
                                         int deletePos,
                                         StyledParagraph oldParagraph) {

    // We will reuse oldParagraph unless there was a length-1 run
    // at deletePos.  We could do more work and check the individual
    // Font and Decoration runs, but we don't right now...
    deletePos -= aci.getBeginIndex();

    if (oldParagraph.decorations == null && oldParagraph.fonts == null) {
        oldParagraph.length -= 1;
        return oldParagraph;
    }

    if (oldParagraph.getRunLimit(deletePos) == deletePos+1) {
        if (deletePos == 0 || oldParagraph.getRunLimit(deletePos-1) == deletePos) {
            return new StyledParagraph(aci, chars);
        }
    }

    oldParagraph.length -= 1;
    if (oldParagraph.decorations != null) {
        deleteFrom(deletePos,
                   oldParagraph.decorationStarts,
                   oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
        deleteFrom(deletePos,
                   oldParagraph.fontStarts,
                   oldParagraph.fonts.size());
    }
    return oldParagraph;
}
 

/**
 * Dispatches committed text to a client component.
 * Called by composition window.
 *
 * @param client The component that the text should get dispatched to.
 * @param text The iterator providing access to the committed
 *        (and possible composed) text.
 * @param committedCharacterCount The number of committed characters in the text.
 */
synchronized void dispatchCommittedText(Component client,
             AttributedCharacterIterator text,
             int committedCharacterCount) {
    // note that the client is not always the current client component -
    // some host input method adapters may dispatch input method events
    // through the Java event queue, and we may have switched clients while
    // the event was in the queue.
    if (committedCharacterCount == 0
            || text.getEndIndex() <= text.getBeginIndex()) {
        return;
    }
    long time = System.currentTimeMillis();
    dispatchingCommittedText = true;
    try {
        InputMethodRequests req = client.getInputMethodRequests();
        if (req != null) {
            // active client -> send text as InputMethodEvent
            int beginIndex = text.getBeginIndex();
            AttributedCharacterIterator toBeCommitted =
                (new AttributedString(text, beginIndex, beginIndex + committedCharacterCount)).getIterator();

            InputMethodEvent inputEvent = new InputMethodEvent(
                    client,
                    InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
                    toBeCommitted,
                    committedCharacterCount,
                    null, null);

            client.dispatchEvent(inputEvent);
        } else {
            // passive client -> send text as KeyEvents
            char keyChar = text.first();
            while (committedCharacterCount-- > 0 && keyChar != CharacterIterator.DONE) {
                KeyEvent keyEvent = new KeyEvent(client, KeyEvent.KEY_TYPED,
                                             time, 0, KeyEvent.VK_UNDEFINED, keyChar);
                client.dispatchEvent(keyEvent);
                keyChar = text.next();
            }
        }
    } finally {
        dispatchingCommittedText = false;
    }
}
 

/**
 * Dispatches committed text to a client component.
 * Called by composition window.
 *
 * @param client The component that the text should get dispatched to.
 * @param text The iterator providing access to the committed
 *        (and possible composed) text.
 * @param committedCharacterCount The number of committed characters in the text.
 */
synchronized void dispatchCommittedText(Component client,
             AttributedCharacterIterator text,
             int committedCharacterCount) {
    // note that the client is not always the current client component -
    // some host input method adapters may dispatch input method events
    // through the Java event queue, and we may have switched clients while
    // the event was in the queue.
    if (committedCharacterCount == 0
            || text.getEndIndex() <= text.getBeginIndex()) {
        return;
    }
    long time = System.currentTimeMillis();
    dispatchingCommittedText = true;
    try {
        InputMethodRequests req = client.getInputMethodRequests();
        if (req != null) {
            // active client -> send text as InputMethodEvent
            int beginIndex = text.getBeginIndex();
            AttributedCharacterIterator toBeCommitted =
                (new AttributedString(text, beginIndex, beginIndex + committedCharacterCount)).getIterator();

            InputMethodEvent inputEvent = new InputMethodEvent(
                    client,
                    InputMethodEvent.INPUT_METHOD_TEXT_CHANGED,
                    toBeCommitted,
                    committedCharacterCount,
                    null, null);

            client.dispatchEvent(inputEvent);
        } else {
            // passive client -> send text as KeyEvents
            char keyChar = text.first();
            while (committedCharacterCount-- > 0 && keyChar != CharacterIterator.DONE) {
                KeyEvent keyEvent = new KeyEvent(client, KeyEvent.KEY_TYPED,
                                             time, 0, KeyEvent.VK_UNDEFINED, keyChar);
                client.dispatchEvent(keyEvent);
                keyChar = text.next();
            }
        }
    } finally {
        dispatchingCommittedText = false;
    }
}
 

public int length() {
    AttributedCharacterIterator aci = getIterator();
    return aci.getEndIndex() - aci.getBeginIndex();
}
 

/**
 * Serialises an <code>AttributedString</code> object.
 *
 * @param as  the attributed string object (<code>null</code> permitted).
 * @param stream  the output stream (<code>null</code> not permitted).
 *
 * @throws IOException if there is an I/O error.
 */
public static void writeAttributedString(AttributedString as,
        ObjectOutputStream stream) throws IOException {

    if (stream == null) {
        throw new IllegalArgumentException("Null 'stream' argument.");
    }
    if (as != null) {
        stream.writeBoolean(false);
        AttributedCharacterIterator aci = as.getIterator();
        // build a plain string from aci
        // then write the string
        StringBuffer plainStr = new StringBuffer();
        char current = aci.first();
        while (current != CharacterIterator.DONE) {
            plainStr = plainStr.append(current);
            current = aci.next();
        }
        stream.writeObject(plainStr.toString());

        // then write the attributes and limits for each run
        current = aci.first();
        int begin = aci.getBeginIndex();
        while (current != CharacterIterator.DONE) {
            // write the current character - when the reader sees that this
            // is not CharacterIterator.DONE, it will know to read the
            // run limits and attributes
            stream.writeChar(current);

            // now write the limit, adjusted as if beginIndex is zero
            int limit = aci.getRunLimit();
            stream.writeInt(limit - begin);

            // now write the attribute set
            Map atts = new HashMap(aci.getAttributes());
            stream.writeObject(atts);
            current = aci.setIndex(limit);
        }
        // write a character that signals to the reader that all runs
        // are done...
        stream.writeChar(CharacterIterator.DONE);
    }
    else {
        // write a flag that indicates a null
        stream.writeBoolean(true);
    }

}
 

/**
  * Constructs an <code>InputMethodEvent</code> with the specified
  * source component, type, time, text, caret, and visiblePosition.
  * <p>
  * The offsets of caret and visiblePosition are relative to the current
  * composed text; that is, the composed text within <code>text</code>
  * if this is an <code>INPUT_METHOD_TEXT_CHANGED</code> event,
  * the composed text within the <code>text</code> of the
  * preceding <code>INPUT_METHOD_TEXT_CHANGED</code> event otherwise.
  * <p>Note that passing in an invalid <code>id</code> results in
  * unspecified behavior. This method throws an
  * <code>IllegalArgumentException</code> if <code>source</code>
  * is <code>null</code>.
  *
  * @param source the object where the event originated
  * @param id the event type
  * @param when a long integer that specifies the time the event occurred
  * @param text the combined committed and composed text,
  *      committed text first; must be <code>null</code>
  *      when the event type is <code>CARET_POSITION_CHANGED</code>;
  *      may be <code>null</code> for
  *      <code>INPUT_METHOD_TEXT_CHANGED</code> if there's no
  *      committed or composed text
  * @param committedCharacterCount the number of committed
  *      characters in the text
  * @param caret the caret (a.k.a. insertion point);
  *      <code>null</code> if there's no caret within current
  *      composed text
  * @param visiblePosition the position that's most important
  *      to be visible; <code>null</code> if there's no
  *      recommendation for a visible position within current
  *      composed text
  * @throws IllegalArgumentException if <code>id</code> is not
  *      in the range
  *      <code>INPUT_METHOD_FIRST</code>..<code>INPUT_METHOD_LAST</code>;
  *      or if id is <code>CARET_POSITION_CHANGED</code> and
  *      <code>text</code> is not <code>null</code>;
  *      or if <code>committedCharacterCount</code> is not in the range
  *      <code>0</code>..<code>(text.getEndIndex() - text.getBeginIndex())</code>
  * @throws IllegalArgumentException if <code>source</code> is null
  *
  * @since 1.4
  */
 public InputMethodEvent(Component source, int id, long when,
         AttributedCharacterIterator text, int committedCharacterCount,
         TextHitInfo caret, TextHitInfo visiblePosition) {
     super(source, id);
     if (id < INPUT_METHOD_FIRST || id > INPUT_METHOD_LAST) {
         throw new IllegalArgumentException("id outside of valid range");
     }

     if (id == CARET_POSITION_CHANGED && text != null) {
         throw new IllegalArgumentException("text must be null for CARET_POSITION_CHANGED");
     }

     this.when = when;
     this.text = text;
     int textLength = 0;
     if (text != null) {
         textLength = text.getEndIndex() - text.getBeginIndex();
     }

     if (committedCharacterCount < 0 || committedCharacterCount > textLength) {
         throw new IllegalArgumentException("committedCharacterCount outside of valid range");
     }
     this.committedCharacterCount = committedCharacterCount;

     this.caret = caret;
     this.visiblePosition = visiblePosition;
}
 

/**
 * Updates this <code>LineBreakMeasurer</code> after a single
 * character is inserted into the text, and sets the current
 * position to the beginning of the paragraph.
 *
 * @param newParagraph the text after the insertion
 * @param insertPos the position in the text at which the character
 *    is inserted
 * @throws IndexOutOfBoundsException if <code>insertPos</code> is less
 *         than the start of <code>newParagraph</code> or greater than
 *         or equal to the end of <code>newParagraph</code>
 * @throws NullPointerException if <code>newParagraph</code> is
 *         <code>null</code>
 * @see #deleteChar
 */
public void insertChar(AttributedCharacterIterator newParagraph,
                       int insertPos) {

    measurer.insertChar(newParagraph, insertPos);

    limit = newParagraph.getEndIndex();
    pos = start = newParagraph.getBeginIndex();

    charIter.reset(measurer.getChars(), newParagraph.getBeginIndex());
    breakIter.setText(charIter);
}
 

/**
  * Constructs an {@code InputMethodEvent} with the specified
  * source component, type, time, text, caret, and visiblePosition.
  * <p>
  * The offsets of caret and visiblePosition are relative to the current
  * composed text; that is, the composed text within {@code text}
  * if this is an {@code INPUT_METHOD_TEXT_CHANGED} event,
  * the composed text within the {@code text} of the
  * preceding {@code INPUT_METHOD_TEXT_CHANGED} event otherwise.
  * <p>Note that passing in an invalid {@code id} results in
  * unspecified behavior. This method throws an
  * {@code IllegalArgumentException} if {@code source}
  * is {@code null}.
  *
  * @param source the object where the event originated
  * @param id the event type
  * @param when a long integer that specifies the time the event occurred
  * @param text the combined committed and composed text,
  *      committed text first; must be {@code null}
  *      when the event type is {@code CARET_POSITION_CHANGED};
  *      may be {@code null} for
  *      {@code INPUT_METHOD_TEXT_CHANGED} if there's no
  *      committed or composed text
  * @param committedCharacterCount the number of committed
  *      characters in the text
  * @param caret the caret (a.k.a. insertion point);
  *      {@code null} if there's no caret within current
  *      composed text
  * @param visiblePosition the position that's most important
  *      to be visible; {@code null} if there's no
  *      recommendation for a visible position within current
  *      composed text
  * @throws IllegalArgumentException if {@code id} is not
  *      in the range
  *      {@code INPUT_METHOD_FIRST}..{@code INPUT_METHOD_LAST};
  *      or if id is {@code CARET_POSITION_CHANGED} and
  *      {@code text} is not {@code null};
  *      or if {@code committedCharacterCount} is not in the range
  *      {@code 0}..{@code (text.getEndIndex() - text.getBeginIndex())}
  * @throws IllegalArgumentException if {@code source} is null
  *
  * @since 1.4
  */
 public InputMethodEvent(Component source, int id, long when,
         AttributedCharacterIterator text, int committedCharacterCount,
         TextHitInfo caret, TextHitInfo visiblePosition) {
     super(source, id);
     if (id < INPUT_METHOD_FIRST || id > INPUT_METHOD_LAST) {
         throw new IllegalArgumentException("id outside of valid range");
     }

     if (id == CARET_POSITION_CHANGED && text != null) {
         throw new IllegalArgumentException("text must be null for CARET_POSITION_CHANGED");
     }

     this.when = when;
     this.text = text;
     int textLength = 0;
     if (text != null) {
         textLength = text.getEndIndex() - text.getBeginIndex();
     }

     if (committedCharacterCount < 0 || committedCharacterCount > textLength) {
         throw new IllegalArgumentException("committedCharacterCount outside of valid range");
     }
     this.committedCharacterCount = committedCharacterCount;

     this.caret = caret;
     this.visiblePosition = visiblePosition;
}
 

/**
 * Updates this <code>LineBreakMeasurer</code> after a single
 * character is inserted into the text, and sets the current
 * position to the beginning of the paragraph.
 *
 * @param newParagraph the text after the insertion
 * @param insertPos the position in the text at which the character
 *    is inserted
 * @throws IndexOutOfBoundsException if <code>insertPos</code> is less
 *         than the start of <code>newParagraph</code> or greater than
 *         or equal to the end of <code>newParagraph</code>
 * @throws NullPointerException if <code>newParagraph</code> is
 *         <code>null</code>
 * @see #deleteChar
 */
public void insertChar(AttributedCharacterIterator newParagraph,
                       int insertPos) {

    measurer.insertChar(newParagraph, insertPos);

    limit = newParagraph.getEndIndex();
    pos = start = newParagraph.getBeginIndex();

    charIter.reset(measurer.getChars(), newParagraph.getBeginIndex());
    breakIter.setText(charIter);
}