sun.font.Decoration Java Examples

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Add a new Decoration run with the given Decoration at the
 * given index.
 */
private void addDecoration(Decoration d, int index) {

    if (decorations != null) {
        decorationStarts = addToVector(d,
                                       index,
                                       decorations,
                                       decorationStarts);
    }
    else if (decoration == null) {
        decoration = d;
    }
    else {
        if (!decoration.equals(d)) {
            decorations = new Vector<Decoration>(INITIAL_SIZE);
            decorations.addElement(decoration);
            decorations.addElement(d);
            decorationStarts = new int[INITIAL_SIZE];
            decorationStarts[0] = 0;
            decorationStarts[1] = index;
        }
    }
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * Return the Decoration in effect at the given index.
 * @param index a valid index in the paragraph
 * @return the Decoration at index.
 */
public Decoration getDecorationAt(int index) {

    if (index < 0 || index >= length) {
        throw new IllegalArgumentException("index out of range");
    }
    if (decorations == null) {
        return decoration;
    }
    int run = findRunContaining(index, decorationStarts);
    return decorations.elementAt(run);
}
 

/**
 * 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 inserting a single character at insertPos.
 * @param chars the characters in aci
 * @param insertPos the index of the new character in aci
 * @param oldParagraph a StyledParagraph for the text in aci before the
 *     insertion
 */
public static StyledParagraph insertChar(AttributedCharacterIterator aci,
                                         char[] chars,
                                         int insertPos,
                                         StyledParagraph oldParagraph) {

    // If the styles at insertPos match those at insertPos-1,
    // oldParagraph will be reused.  Otherwise we create a new
    // paragraph.

    char ch = aci.setIndex(insertPos);
    int relativePos = Math.max(insertPos - aci.getBeginIndex() - 1, 0);

    Map<? extends Attribute, ?> attributes =
        addInputMethodAttrs(aci.getAttributes());
    Decoration d = Decoration.getDecoration(attributes);
    if (!oldParagraph.getDecorationAt(relativePos).equals(d)) {
        return new StyledParagraph(aci, chars);
    }
    Object f = getGraphicOrFont(attributes);
    if (f == null) {
        FontResolver resolver = FontResolver.getInstance();
        int fontIndex = resolver.getFontIndex(ch);
        f = resolver.getFont(fontIndex, attributes);
    }
    if (!oldParagraph.getFontOrGraphicAt(relativePos).equals(f)) {
        return new StyledParagraph(aci, chars);
    }

    // insert into existing paragraph
    oldParagraph.length += 1;
    if (oldParagraph.decorations != null) {
        insertInto(relativePos,
                   oldParagraph.decorationStarts,
                   oldParagraph.decorations.size());
    }
    if (oldParagraph.fonts != null) {
        insertInto(relativePos,
                   oldParagraph.fontStarts,
                   oldParagraph.fonts.size());
    }
    return oldParagraph;
}
 

/**
 * Returns an array in logical order of the TextLineComponents on
 * the text in the given range, with the given attributes.
 */
public static TextLineComponent[] createComponentsOnRun(int runStart,
                                                        int runLimit,
                                                        char[] chars,
                                                        int[] charsLtoV,
                                                        byte[] levels,
                                                        TextLabelFactory factory,
                                                        Font font,
                                                        CoreMetrics cm,
                                                        FontRenderContext frc,
                                                        Decoration decorator,
                                                        TextLineComponent[] components,
                                                        int numComponents) {

    int pos = runStart;
    do {
        int chunkLimit = firstVisualChunk(charsLtoV, levels, pos, runLimit); // <= displayLimit

        do {
            int startPos = pos;
            int lmCount;

            if (cm == null) {
                LineMetrics lineMetrics = font.getLineMetrics(chars, startPos, chunkLimit, frc);
                cm = CoreMetrics.get(lineMetrics);
                lmCount = lineMetrics.getNumChars();
            }
            else {
                lmCount = (chunkLimit-startPos);
            }

            TextLineComponent nextComponent =
                factory.createExtended(font, cm, decorator, startPos, startPos + lmCount);

            ++numComponents;
            if (numComponents >= components.length) {
                components = expandArray(components);
            }

            components[numComponents-1] = nextComponent;

            pos += lmCount;
        } while (pos < chunkLimit);

    } while (pos < runLimit);

    return components;
}