Added documentation for SpannableStringBuilder.getTextRunCursor

    /**

     * Return the char at the specified offset within the buffer.

     */

    @Override

    public char charAt(int where) {

        int len = length();

        if (where < 0) {

    /**

     * Return the number of chars in the buffer.

     */

    @Override

    public int length() {

        return mText.length - mGapLength;

    }

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder insert(int where, CharSequence tb, int start, int end) {

        return replace(where, where, tb, start, end);

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder insert(int where, CharSequence tb) {

        return replace(where, where, tb, 0, tb.length());

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder delete(int start, int end) {

        SpannableStringBuilder ret = replace(start, end, "", 0, 0);

    }

    // Documentation from interface

    @Override

    public void clear() {

        replace(0, length(), "", 0, 0);

    }

    // Documentation from interface

    @Override

    public void clearSpans() {

        for (int i = mSpanCount - 1; i >= 0; i--) {

            Object what = mSpans[i];

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder append(CharSequence text) {

        int length = length();

        return replace(length, length, text, 0, text.length());

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder append(CharSequence text, int start, int end) {

        int length = length();

        return replace(length, length, text, start, end);

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder append(char text) {

        return append(String.valueOf(text));

    }

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder replace(int start, int end, CharSequence tb) {

        return replace(start, end, tb, 0, tb.length());

    }

    // Documentation from interface

    @Override

    public SpannableStringBuilder replace(final int start, final int end,

                        CharSequence tb, int tbstart, int tbend) {

        int filtercount = mFilters.length;

     * The flags determine how the span will behave when text is

     * inserted at the start or end of the span's range.

     */

    @Override

    public void setSpan(Object what, int start, int end, int flags) {

        setSpan(true, what, start, end, flags);

    }

    /**

     * Remove the specified markup object from the buffer.

     */

    @Override

    public void removeSpan(Object what) {

        for (int i = mSpanCount - 1; i >= 0; i--) {

            if (mSpans[i] == what) {

     * Return the buffer offset of the beginning of the specified

     * markup object, or -1 if it is not attached to this buffer.

     */

    @Override

    public int getSpanStart(Object what) {

        int count = mSpanCount;

        Object[] spans = mSpans;

     * Return the buffer offset of the end of the specified

     * markup object, or -1 if it is not attached to this buffer.

     */

    @Override

    public int getSpanEnd(Object what) {

        int count = mSpanCount;

        Object[] spans = mSpans;

     * Return the flags of the end of the specified

     * markup object, or 0 if it is not attached to this buffer.

     */

    @Override

    public int getSpanFlags(Object what) {

        int count = mSpanCount;

        Object[] spans = mSpans;

     * the specified range of the buffer.  The kind may be Object.class to get

     * a list of all the spans regardless of type.

     */

    @Override

    @SuppressWarnings("unchecked")

    public <T> T[] getSpans(int queryStart, int queryEnd, Class<T> kind) {

        int spanCount = mSpanCount;

     * equal to <code>limit</code> where a span of the specified type

     * begins or ends.

     */

    @Override

    public int nextSpanTransition(int start, int limit, Class kind) {

        int count = mSpanCount;

        Object[] spans = mSpans;

     * Return a new CharSequence containing a copy of the specified

     * range of this buffer, including the overlapping spans.

     */

    @Override

    public CharSequence subSequence(int start, int end) {

        return new SpannableStringBuilder(this, start, end);

    }

     * Copy the specified range of chars from this buffer into the

     * specified array, beginning at the specified offset.

     */

    @Override

    public void getChars(int start, int end, char[] dest, int destoff) {

        checkRange("getChars", start, end);

     * Don't call this yourself -- exists for Canvas to use internally.

     * {@hide}

     */

    @Override

    public void drawText(Canvas c, int start, int end,

                         float x, float y, Paint p) {

        checkRange("drawText", start, end);

     * Don't call this yourself -- exists for Canvas to use internally.

     * {@hide}

     */

    @Override

    public void drawTextRun(Canvas c, int start, int end,

            int contextStart, int contextEnd,

            float x, float y, int flags, Paint p) {

     * Don't call this yourself -- exists for Paint to use internally.

     * {@hide}

     */

    @Override

    public float measureText(int start, int end, Paint p) {

        checkRange("measureText", start, end);

     * Don't call this yourself -- exists for Paint to use internally.

     * {@hide}

     */

    @Override

    public int getTextWidths(int start, int end, float[] widths, Paint p) {

        checkRange("getTextWidths", start, end);

     * Don't call this yourself -- exists for Paint to use internally.

     * {@hide}

     */

    @Override

    public float getTextRunAdvances(int start, int end, int contextStart, int contextEnd, int flags,

            float[] advances, int advancesPos, Paint p) {

        return ret;

    }

    /**

     * Returns the next cursor position in the run.  This avoids placing the cursor between

     * surrogates, between characters that form conjuncts, between base characters and combining

     * marks, or within a reordering cluster.

     *

     * <p>The context is the shaping context for cursor movement, generally the bounds of the metric

     * span enclosing the cursor in the direction of movement.

     * <code>contextStart</code>, <code>contextEnd</code> and <code>offset</code> are relative to

     * the start of the string.</p>

     *

     * <p>If cursorOpt is {@link Paint#CURSOR_AT} and the offset is not a valid cursor position,

     * this returns -1.  Otherwise this will never return a value before contextStart or after

     * contextEnd.</p>

     *

     * @param contextStart the start index of the context

     * @param contextEnd the (non-inclusive) end index of the context

     * @param flags either {@link Paint#DIRECTION_RTL} or {@link Paint#DIRECTION_LTR}

     * @param offset the cursor position to move from

     * @param cursorOpt how to move the cursor, one of {@link Paint#CURSOR_AFTER},

     * {@link Paint#CURSOR_AT_OR_AFTER}, {@link Paint#CURSOR_BEFORE},

     * {@link Paint#CURSOR_AT_OR_BEFORE}, or {@link Paint#CURSOR_AT}

     * @param p the Paint object that is requesting this information

     * @return the offset of the next position, or -1

     */

    @Override

    public int getTextRunCursor(int contextStart, int contextEnd, int flags, int offset,

            int cursorOpt, Paint p) {

    }

    // Documentation from interface

    @Override

    public void setFilters(InputFilter[] filters) {

        if (filters == null) {

            throw new IllegalArgumentException();

    }

    // Documentation from interface

    @Override

    public InputFilter[] getFilters() {

        return mFilters;

    }