Java AttributedCharacterIterator.getEndIndex方法代码示例

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
private List<String> getEntities(TextEntity entity) {
  AttributedCharacterIterator iterator = getIterator();
  List<String> entities = new ArrayList<>();
  StringBuilder builder = new StringBuilder();

  Map<AttributedCharacterIterator.Attribute, Object> last = Collections.emptyMap();
  while (iterator.getIndex() != iterator.getEndIndex()) {
    Map<AttributedCharacterIterator.Attribute, Object> curr = iterator.getAttributes();
    if (curr.containsKey(entity)) {
      builder.append(iterator.current());
    } else {
      if (last.containsKey(entity)) {
        entities.add(builder.toString());
        builder.setLength(0);
      }
    }
    last = curr;

    iterator.next();
  }
  if (last.containsKey(entity)) {
    entities.add(builder.toString());
  }

  return entities;
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
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;
    }
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> List<Map.Entry<String, T>> getEntitiesWithValues(TextEntity entity) {
  AttributedCharacterIterator iterator = getIterator();
  List<Map.Entry<String, T>> entities = new ArrayList<>();
  StringBuilder builder = new StringBuilder();

  Map<AttributedCharacterIterator.Attribute, T> last = Collections.emptyMap();
  while (iterator.getIndex() != iterator.getEndIndex()) {
    Map<AttributedCharacterIterator.Attribute, T> curr =
        (Map<AttributedCharacterIterator.Attribute, T>) iterator.getAttributes();
    if (curr.containsKey(entity)) {
      builder.append(iterator.current());
    } else {
      if (last.containsKey(entity)) {
        entities.add(
            new AbstractMap.SimpleImmutableEntry<>(builder.toString(), last.get(entity))
        );
        builder.setLength(0);
      }
    }
    last = curr;

    iterator.next();
  }
  if (last.containsKey(entity)) {
    entities.add(
        new AbstractMap.SimpleImmutableEntry<>(builder.toString(), last.get(entity))
    );
  }

  return entities;
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
@Override
public boolean equals(Object obj) {
  if (obj == this) {
    return true;
  }

  if(!(obj instanceof Text)) {
    return false;
  }

  Text text = (Text) obj;

  if (this.length() != text.length()) {
    return false;
  }

  AttributedCharacterIterator it1 = this.getIterator();
  AttributedCharacterIterator it2 = text.getIterator();
  while (true) {
    if (it1.getIndex() == it1.getEndIndex()) {
      break;
    }

    if (it1.next() != it2.next()) {
      return false;
    }
    Map map1 = it1.getAttributes();
    Map map2 = it2.getAttributes();
    if (!map1.equals(map2)) {
      return false;
    }
  }
  return true;
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
 * 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);
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
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);
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
@Override
public Dimension getPreferredSize(JComponent c) {
    String tipText = ((JToolTip)c).getTipText();
    if (tipText == null || tipText.isEmpty()) {
        return new Dimension(0, 0);
    }

    float x = 0f;
    float y = 0f;
    for (String line : lineBreak.split(tipText)) {
        if (line.isEmpty()) {
            y += LEADING;
            continue;
        }
        AttributedCharacterIterator styledText
            = new AttributedString(line).getIterator();
        LineBreakMeasurer measurer = new LineBreakMeasurer(styledText, frc);

        while (measurer.getPosition() < styledText.getEndIndex()) {

            TextLayout layout = measurer.nextLayout(maximumWidth);

            x = Math.max(x, layout.getVisibleAdvance());
            y += layout.getAscent() + layout.getDescent() + layout.getLeading();

        }
    }
    return new Dimension((int) (x + 2 * margin),
                         (int) (y + 2 * margin));

}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
 * Constructs a {@code TextLayout} 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} 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);
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
public void drawString(AttributedCharacterIterator iterator,
                       float x, float 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, x, y);
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
 * 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;
    }
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
public void formatAndAppend(Format formatter, Object arg) {
    if (attributes == null) {
        append(formatter.format(arg));
    } else {
        AttributedCharacterIterator formattedArg = formatter.formatToCharacterIterator(arg);
        int prevLength = length;
        append(formattedArg);
        // Copy all of the attributes from formattedArg to our attributes list.
        formattedArg.first();
        int start = formattedArg.getIndex();  // Should be 0 but might not be.
        int limit = formattedArg.getEndIndex();  // == start + length - prevLength
        int offset = prevLength - start;  // Adjust attribute indexes for the result string.
        while (start < limit) {
            Map<Attribute, Object> map = formattedArg.getAttributes();
            int runLimit = formattedArg.getRunLimit();
            if (map.size() != 0) {
                for (Map.Entry<Attribute, Object> entry : map.entrySet()) {
                   attributes.add(
                       new AttributeAndPosition(
                           entry.getKey(), entry.getValue(),
                           offset + start, offset + runLimit));
                }
            }
            start = runLimit;
            formattedArg.setIndex(start);
        }
    }
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
 * Create a new StyledParagraph over the given styled text.
 * @param aci an iterator over the text
 * @param chars the characters extracted from aci
 */
public StyledParagraph(AttributedCharacterIterator aci,
                       char[] chars) {

    int start = aci.getBeginIndex();
    int end = aci.getEndIndex();
    length = end - start;

    int index = start;
    aci.first();

    do {
        final int nextRunStart = aci.getRunLimit();
        final int localIndex = index-start;

        Map<? extends Attribute, ?> attributes = aci.getAttributes();
        attributes = addInputMethodAttrs(attributes);
        Decoration d = Decoration.getDecoration(attributes);
        addDecoration(d, localIndex);

        Object f = getGraphicOrFont(attributes);
        if (f == null) {
            addFonts(chars, attributes, localIndex, nextRunStart-start);
        }
        else {
            addFont(f, localIndex);
        }

        aci.setIndex(nextRunStart);
        index = nextRunStart;

    } while (index < end);

    // Add extra entries to starts arrays with the length
    // of the paragraph.  'this' is used as a dummy value
    // in the Vector.
    if (decorations != null) {
        decorationStarts = addToVector(this, length, decorations, decorationStarts);
    }
    if (fonts != null) {
        fontStarts = addToVector(this, length, fonts, fontStarts);
    }
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
  * 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;
}
 

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
 * Updates this <code>LineBreakMeasurer</code> after a single
 * character is deleted from the text, and sets the current
 * position to the beginning of the paragraph.
 * @param newParagraph the text after the deletion
 * @param deletePos the position in the text at which the character
 *    is deleted
 * @throws IndexOutOfBoundsException if <code>deletePos</code> is
 *         less than the start of <code>newParagraph</code> or greater
 *         than the end of <code>newParagraph</code>
 * @throws NullPointerException if <code>newParagraph</code> is
 *         <code>null</code>
 * @see #insertChar
 */
public void deleteChar(AttributedCharacterIterator newParagraph,
                       int deletePos) {

    measurer.deleteChar(newParagraph, deletePos);

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

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

import java.text.AttributedCharacterIterator; //导入方法依赖的package包/类
/**
  * 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;
}