Java 类sun.font.GlyphLayout 实例源码

项目:OpenJSharp    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:jdk8u-jdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:openjdk-jdk10    文件:Font.java   
/**
 * Returns a new {@code GlyphVector} object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * {@code Bidi}, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified {@code FontRenderContext}
 * @param text the text to layout
 * @param start the start of the text to use for the {@code GlyphVector}
 * @param limit the limit of the text to use for the {@code GlyphVector}
 * @param flags control flags as described above
 * @return a new {@code GlyphVector} representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:openjdk9    文件:Font.java   
/**
 * Returns a new {@code GlyphVector} object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * {@code Bidi}, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified {@code FontRenderContext}
 * @param text the text to layout
 * @param start the start of the text to use for the {@code GlyphVector}
 * @param limit the limit of the text to use for the {@code GlyphVector}
 * @param flags control flags as described above
 * @return a new {@code GlyphVector} representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:Java8CN    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:jdk8u_jdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:lookaside_java-1.8.0-openjdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:VarJ    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.  
 * <p>
 * Layout requires bidi analysis, as performed by 
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or 
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English) 
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require 
 * context, so that the characters at the start and limit can have 
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 * 
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent 
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is 
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:jdk-1.7-annotated    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:infobip-open-jdk-8    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:jdk8u-dev-jdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:jdk7-jdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:openjdk-source-code-learn    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:OLD-OpenJDK8    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:openjdk-jdk7u-jdk    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}
项目:openjdk-icedtea7    文件:Font.java   
/**
 * Returns a new <code>GlyphVector</code> object, performing full
 * layout of the text if possible.  Full layout is required for
 * complex text, such as Arabic or Hindi.  Support for different
 * scripts depends on the font and implementation.
 * <p>
 * Layout requires bidi analysis, as performed by
 * <code>Bidi</code>, and should only be performed on text that
 * has a uniform direction.  The direction is indicated in the
 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
 * right-to-left (Arabic and Hebrew) run direction, or
 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
 * run direction.
 * <p>
 * In addition, some operations, such as Arabic shaping, require
 * context, so that the characters at the start and limit can have
 * the proper shapes.  Sometimes the data in the buffer outside
 * the provided range does not have valid data.  The values
 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
 * added to the flags parameter to indicate that the text before
 * start, or after limit, respectively, should not be examined
 * for context.
 * <p>
 * All other values for the flags parameter are reserved.
 *
 * @param frc the specified <code>FontRenderContext</code>
 * @param text the text to layout
 * @param start the start of the text to use for the <code>GlyphVector</code>
 * @param limit the limit of the text to use for the <code>GlyphVector</code>
 * @param flags control flags as described above
 * @return a new <code>GlyphVector</code> representing the text between
 * start and limit, with glyphs chosen and positioned so as to best represent
 * the text
 * @throws ArrayIndexOutOfBoundsException if start or limit is
 * out of bounds
 * @see java.text.Bidi
 * @see #LAYOUT_LEFT_TO_RIGHT
 * @see #LAYOUT_RIGHT_TO_LEFT
 * @see #LAYOUT_NO_START_CONTEXT
 * @see #LAYOUT_NO_LIMIT_CONTEXT
 * @since 1.4
 */
public GlyphVector layoutGlyphVector(FontRenderContext frc,
                                     char[] text,
                                     int start,
                                     int limit,
                                     int flags) {

    GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
    StandardGlyphVector gv = gl.layout(this, frc, text,
                                       start, limit-start, flags, null);
    GlyphLayout.done(gl);
    return gv;
}