/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.text; import com.android.internal.R; import com.android.internal.util.ArrayUtils; import android.content.res.Resources; import android.os.Parcel; import android.os.Parcelable; import android.text.style.AbsoluteSizeSpan; import android.text.style.AlignmentSpan; import android.text.style.BackgroundColorSpan; import android.text.style.BulletSpan; import android.text.style.CharacterStyle; import android.text.style.ForegroundColorSpan; import android.text.style.LeadingMarginSpan; import android.text.style.MetricAffectingSpan; import android.text.style.QuoteSpan; import android.text.style.RelativeSizeSpan; import android.text.style.ReplacementSpan; import android.text.style.ScaleXSpan; import android.text.style.StrikethroughSpan; import android.text.style.StyleSpan; import android.text.style.SubscriptSpan; import android.text.style.SuperscriptSpan; import android.text.style.TextAppearanceSpan; import android.text.style.TypefaceSpan; import android.text.style.URLSpan; import android.text.style.UnderlineSpan; import android.util.Printer; import java.util.Iterator; import java.util.regex.Pattern; public class TextUtils { private TextUtils() { /* cannot be instantiated */ } private static String[] EMPTY_STRING_ARRAY = new String[]{}; public static void getChars(CharSequence s, int start, int end, char[] dest, int destoff) { Class c = s.getClass(); if (c == String.class) ((String) s).getChars(start, end, dest, destoff); else if (c == StringBuffer.class) ((StringBuffer) s).getChars(start, end, dest, destoff); else if (c == StringBuilder.class) ((StringBuilder) s).getChars(start, end, dest, destoff); else if (s instanceof GetChars) ((GetChars) s).getChars(start, end, dest, destoff); else { for (int i = start; i < end; i++) dest[destoff++] = s.charAt(i); } } public static int indexOf(CharSequence s, char ch) { return indexOf(s, ch, 0); } public static int indexOf(CharSequence s, char ch, int start) { Class c = s.getClass(); if (c == String.class) return ((String) s).indexOf(ch, start); return indexOf(s, ch, start, s.length()); } public static int indexOf(CharSequence s, char ch, int start, int end) { Class c = s.getClass(); if (s instanceof GetChars || c == StringBuffer.class || c == StringBuilder.class || c == String.class) { final int INDEX_INCREMENT = 500; char[] temp = obtain(INDEX_INCREMENT); while (start < end) { int segend = start + INDEX_INCREMENT; if (segend > end) segend = end; getChars(s, start, segend, temp, 0); int count = segend - start; for (int i = 0; i < count; i++) { if (temp[i] == ch) { recycle(temp); return i + start; } } start = segend; } recycle(temp); return -1; } for (int i = start; i < end; i++) if (s.charAt(i) == ch) return i; return -1; } public static int lastIndexOf(CharSequence s, char ch) { return lastIndexOf(s, ch, s.length() - 1); } public static int lastIndexOf(CharSequence s, char ch, int last) { Class c = s.getClass(); if (c == String.class) return ((String) s).lastIndexOf(ch, last); return lastIndexOf(s, ch, 0, last); } public static int lastIndexOf(CharSequence s, char ch, int start, int last) { if (last < 0) return -1; if (last >= s.length()) last = s.length() - 1; int end = last + 1; Class c = s.getClass(); if (s instanceof GetChars || c == StringBuffer.class || c == StringBuilder.class || c == String.class) { final int INDEX_INCREMENT = 500; char[] temp = obtain(INDEX_INCREMENT); while (start < end) { int segstart = end - INDEX_INCREMENT; if (segstart < start) segstart = start; getChars(s, segstart, end, temp, 0); int count = end - segstart; for (int i = count - 1; i >= 0; i--) { if (temp[i] == ch) { recycle(temp); return i + segstart; } } end = segstart; } recycle(temp); return -1; } for (int i = end - 1; i >= start; i--) if (s.charAt(i) == ch) return i; return -1; } public static int indexOf(CharSequence s, CharSequence needle) { return indexOf(s, needle, 0, s.length()); } public static int indexOf(CharSequence s, CharSequence needle, int start) { return indexOf(s, needle, start, s.length()); } public static int indexOf(CharSequence s, CharSequence needle, int start, int end) { int nlen = needle.length(); if (nlen == 0) return start; char c = needle.charAt(0); for (;;) { start = indexOf(s, c, start); if (start > end - nlen) { break; } if (start < 0) { return -1; } if (regionMatches(s, start, needle, 0, nlen)) { return start; } start++; } return -1; } public static boolean regionMatches(CharSequence one, int toffset, CharSequence two, int ooffset, int len) { char[] temp = obtain(2 * len); getChars(one, toffset, toffset + len, temp, 0); getChars(two, ooffset, ooffset + len, temp, len); boolean match = true; for (int i = 0; i < len; i++) { if (temp[i] != temp[i + len]) { match = false; break; } } recycle(temp); return match; } /** * Create a new String object containing the given range of characters * from the source string. This is different than simply calling * {@link CharSequence#subSequence(int, int) CharSequence.subSequence} * in that it does not preserve any style runs in the source sequence, * allowing a more efficient implementation. */ public static String substring(CharSequence source, int start, int end) { if (source instanceof String) return ((String) source).substring(start, end); if (source instanceof StringBuilder) return ((StringBuilder) source).substring(start, end); if (source instanceof StringBuffer) return ((StringBuffer) source).substring(start, end); char[] temp = obtain(end - start); getChars(source, start, end, temp, 0); String ret = new String(temp, 0, end - start); recycle(temp); return ret; } /** * Returns a string containing the tokens joined by delimiters. * @param tokens an array objects to be joined. Strings will be formed from * the objects by calling object.toString(). */ public static String join(CharSequence delimiter, Object[] tokens) { StringBuilder sb = new StringBuilder(); boolean firstTime = true; for (Object token: tokens) { if (firstTime) { firstTime = false; } else { sb.append(delimiter); } sb.append(token); } return sb.toString(); } /** * Returns a string containing the tokens joined by delimiters. * @param tokens an array objects to be joined. Strings will be formed from * the objects by calling object.toString(). */ public static String join(CharSequence delimiter, Iterable tokens) { StringBuilder sb = new StringBuilder(); boolean firstTime = true; for (Object token: tokens) { if (firstTime) { firstTime = false; } else { sb.append(delimiter); } sb.append(token); } return sb.toString(); } /** * String.split() returns [''] when the string to be split is empty. This returns []. This does * not remove any empty strings from the result. For example split("a,", "," ) returns {"a", ""}. * * @param text the string to split * @param expression the regular expression to match * @return an array of strings. The array will be empty if text is empty * * @throws NullPointerException if expression or text is null */ public static String[] split(String text, String expression) { if (text.length() == 0) { return EMPTY_STRING_ARRAY; } else { return text.split(expression, -1); } } /** * Splits a string on a pattern. String.split() returns [''] when the string to be * split is empty. This returns []. This does not remove any empty strings from the result. * @param text the string to split * @param pattern the regular expression to match * @return an array of strings. The array will be empty if text is empty * * @throws NullPointerException if expression or text is null */ public static String[] split(String text, Pattern pattern) { if (text.length() == 0) { return EMPTY_STRING_ARRAY; } else { return pattern.split(text, -1); } } /** * An interface for splitting strings according to rules that are opaque to the user of this * interface. This also has less overhead than split, which uses regular expressions and * allocates an array to hold the results. * *
The most efficient way to use this class is: * *
* // Once * TextUtils.StringSplitter splitter = new TextUtils.SimpleStringSplitter(delimiter); * * // Once per string to split * splitter.setString(string); * for (String s : splitter) { * ... * } **/ public interface StringSplitter extends Iterable
If the final character in the string to split is the delimiter then no empty string will
* be returned for the empty string after that delimeter. That is, splitting "a,b," on
* comma will return "a", "b", not "a", "b", "".
*/
public static class SimpleStringSplitter implements StringSplitter, Iterator Note: In platform versions 1.1 and earlier, this method only worked well if
* both the arguments were instances of String.template
CharSequence with the corresponding
* values
. "^^" is used to produce a single caret in
* the output. Only up to 9 replacement values are supported,
* "^10" will be produce the first replacement value followed by a
* '0'.
*
* @param template the input text containing "^1"-style
* placeholder values. This object is not modified; a copy is
* returned.
*
* @param values CharSequences substituted into the template. The
* first is substituted for "^1", the second for "^2", and so on.
*
* @return the new CharSequence produced by doing the replacement
*
* @throws IllegalArgumentException if the template requests a
* value that was not provided, or if more than 9 values are
* provided.
*/
public static CharSequence expandTemplate(CharSequence template,
CharSequence... values) {
if (values.length > 9) {
throw new IllegalArgumentException("max of 9 values are supported");
}
SpannableStringBuilder ssb = new SpannableStringBuilder(template);
try {
int i = 0;
while (i < ssb.length()) {
if (ssb.charAt(i) == '^') {
char next = ssb.charAt(i+1);
if (next == '^') {
ssb.delete(i+1, i+2);
++i;
continue;
} else if (Character.isDigit(next)) {
int which = Character.getNumericValue(next) - 1;
if (which < 0) {
throw new IllegalArgumentException(
"template requests value ^" + (which+1));
}
if (which >= values.length) {
throw new IllegalArgumentException(
"template requests value ^" + (which+1) +
"; only " + values.length + " provided");
}
ssb.replace(i, i+2, values[which]);
i += values[which].length();
continue;
}
}
++i;
}
} catch (IndexOutOfBoundsException ignore) {
// happens when ^ is the last character in the string.
}
return ssb;
}
public static int getOffsetBefore(CharSequence text, int offset) {
if (offset == 0)
return 0;
if (offset == 1)
return 0;
char c = text.charAt(offset - 1);
if (c >= '\uDC00' && c <= '\uDFFF') {
char c1 = text.charAt(offset - 2);
if (c1 >= '\uD800' && c1 <= '\uDBFF')
offset -= 2;
else
offset -= 1;
} else {
offset -= 1;
}
if (text instanceof Spanned) {
ReplacementSpan[] spans = ((Spanned) text).getSpans(offset, offset,
ReplacementSpan.class);
for (int i = 0; i < spans.length; i++) {
int start = ((Spanned) text).getSpanStart(spans[i]);
int end = ((Spanned) text).getSpanEnd(spans[i]);
if (start < offset && end > offset)
offset = start;
}
}
return offset;
}
public static int getOffsetAfter(CharSequence text, int offset) {
int len = text.length();
if (offset == len)
return len;
if (offset == len - 1)
return len;
char c = text.charAt(offset);
if (c >= '\uD800' && c <= '\uDBFF') {
char c1 = text.charAt(offset + 1);
if (c1 >= '\uDC00' && c1 <= '\uDFFF')
offset += 2;
else
offset += 1;
} else {
offset += 1;
}
if (text instanceof Spanned) {
ReplacementSpan[] spans = ((Spanned) text).getSpans(offset, offset,
ReplacementSpan.class);
for (int i = 0; i < spans.length; i++) {
int start = ((Spanned) text).getSpanStart(spans[i]);
int end = ((Spanned) text).getSpanEnd(spans[i]);
if (start < offset && end > offset)
offset = end;
}
}
return offset;
}
private static void readSpan(Parcel p, Spannable sp, Object o) {
sp.setSpan(o, p.readInt(), p.readInt(), p.readInt());
}
/**
* Copies the spans from the region start...end
in
* source
to the region
* destoff...destoff+end-start
in dest
.
* Spans in source
that begin before start
* or end after end
but overlap this range are trimmed
* as if they began at start
or ended at end
.
*
* @throws IndexOutOfBoundsException if any of the copied spans
* are out of range in dest
.
*/
public static void copySpansFrom(Spanned source, int start, int end,
Class kind,
Spannable dest, int destoff) {
if (kind == null) {
kind = Object.class;
}
Object[] spans = source.getSpans(start, end, kind);
for (int i = 0; i < spans.length; i++) {
int st = source.getSpanStart(spans[i]);
int en = source.getSpanEnd(spans[i]);
int fl = source.getSpanFlags(spans[i]);
if (st < start)
st = start;
if (en > end)
en = end;
dest.setSpan(spans[i], st - start + destoff, en - start + destoff,
fl);
}
}
public enum TruncateAt {
START,
MIDDLE,
END,
MARQUEE,
}
public interface EllipsizeCallback {
/**
* This method is called to report that the specified region of
* text was ellipsized away by a call to {@link #ellipsize}.
*/
public void ellipsized(int start, int end);
}
private static String sEllipsis = null;
/**
* Returns the original text if it fits in the specified width
* given the properties of the specified Paint,
* or, if it does not fit, a truncated
* copy with ellipsis character added at the specified edge or center.
*/
public static CharSequence ellipsize(CharSequence text,
TextPaint p,
float avail, TruncateAt where) {
return ellipsize(text, p, avail, where, false, null);
}
/**
* Returns the original text if it fits in the specified width
* given the properties of the specified Paint,
* or, if it does not fit, a copy with ellipsis character added
* at the specified edge or center.
* If preserveLength
is specified, the returned copy
* will be padded with zero-width spaces to preserve the original
* length and offsets instead of truncating.
* If callback
is non-null, it will be called to
* report the start and end of the ellipsized range.
*/
public static CharSequence ellipsize(CharSequence text,
TextPaint paint,
float avail, TruncateAt where,
boolean preserveLength,
EllipsizeCallback callback) {
if (sEllipsis == null) {
Resources r = Resources.getSystem();
sEllipsis = r.getString(R.string.ellipsis);
}
int len = text.length();
MeasuredText mt = MeasuredText.obtain();
try {
float width = setPara(mt, paint, text, 0, text.length(),
Layout.DIR_REQUEST_DEFAULT_LTR);
if (width <= avail) {
if (callback != null) {
callback.ellipsized(0, 0);
}
return text;
}
// XXX assumes ellipsis string does not require shaping and
// is unaffected by style
float ellipsiswid = paint.measureText(sEllipsis);
avail -= ellipsiswid;
int left = 0;
int right = len;
if (avail < 0) {
// it all goes
} else if (where == TruncateAt.START) {
right = len - mt.breakText(0, len, false, avail);
} else if (where == TruncateAt.END) {
left = mt.breakText(0, len, true, avail);
} else {
right = len - mt.breakText(0, len, false, avail / 2);
avail -= mt.measure(right, len);
left = mt.breakText(0, right, true, avail);
}
if (callback != null) {
callback.ellipsized(left, right);
}
char[] buf = mt.mChars;
Spanned sp = text instanceof Spanned ? (Spanned) text : null;
int remaining = len - (right - left);
if (preserveLength) {
if (remaining > 0) { // else eliminate the ellipsis too
buf[left++] = '\u2026';
}
for (int i = left; i < right; i++) {
buf[i] = '\uFEFF';
}
String s = new String(buf, 0, len);
if (sp == null) {
return s;
}
SpannableString ss = new SpannableString(s);
copySpansFrom(sp, 0, len, Object.class, ss, 0);
return ss;
}
if (remaining == 0) {
return "";
}
if (sp == null) {
StringBuilder sb = new StringBuilder(remaining + sEllipsis.length());
sb.append(buf, 0, left);
sb.append(sEllipsis);
sb.append(buf, right, len - right);
return sb.toString();
}
SpannableStringBuilder ssb = new SpannableStringBuilder();
ssb.append(text, 0, left);
ssb.append(sEllipsis);
ssb.append(text, right, len);
return ssb;
} finally {
MeasuredText.recycle(mt);
}
}
/**
* Converts a CharSequence of the comma-separated form "Andy, Bob,
* Charles, David" that is too wide to fit into the specified width
* into one like "Andy, Bob, 2 more".
*
* @param text the text to truncate
* @param p the Paint with which to measure the text
* @param avail the horizontal width available for the text
* @param oneMore the string for "1 more" in the current locale
* @param more the string for "%d more" in the current locale
*/
public static CharSequence commaEllipsize(CharSequence text,
TextPaint p, float avail,
String oneMore,
String more) {
MeasuredText mt = MeasuredText.obtain();
try {
int len = text.length();
float width = setPara(mt, p, text, 0, len, Layout.DIR_REQUEST_DEFAULT_LTR);
if (width <= avail) {
return text;
}
char[] buf = mt.mChars;
int commaCount = 0;
for (int i = 0; i < len; i++) {
if (buf[i] == ',') {
commaCount++;
}
}
int remaining = commaCount + 1;
int ok = 0;
int okRemaining = remaining;
String okFormat = "";
int w = 0;
int count = 0;
float[] widths = mt.mWidths;
int request = mt.mDir == 1 ? Layout.DIR_REQUEST_LTR :
Layout.DIR_REQUEST_RTL;
MeasuredText tempMt = MeasuredText.obtain();
for (int i = 0; i < len; i++) {
w += widths[i];
if (buf[i] == ',') {
count++;
String format;
// XXX should not insert spaces, should be part of string
// XXX should use plural rules and not assume English plurals
if (--remaining == 1) {
format = " " + oneMore;
} else {
format = " " + String.format(more, remaining);
}
// XXX this is probably ok, but need to look at it more
tempMt.setPara(format, 0, format.length(), request);
float moreWid = tempMt.addStyleRun(p, tempMt.mLen, null);
if (w + moreWid <= avail) {
ok = i + 1;
okRemaining = remaining;
okFormat = format;
}
}
}
MeasuredText.recycle(tempMt);
SpannableStringBuilder out = new SpannableStringBuilder(okFormat);
out.insert(0, text, 0, ok);
return out;
} finally {
MeasuredText.recycle(mt);
}
}
private static float setPara(MeasuredText mt, TextPaint paint,
CharSequence text, int start, int end, int bidiRequest) {
mt.setPara(text, start, end, bidiRequest);
float width;
Spanned sp = text instanceof Spanned ? (Spanned) text : null;
int len = end - start;
if (sp == null) {
width = mt.addStyleRun(paint, len, null);
} else {
width = 0;
int spanEnd;
for (int spanStart = 0; spanStart < len; spanStart = spanEnd) {
spanEnd = sp.nextSpanTransition(spanStart, len,
MetricAffectingSpan.class);
MetricAffectingSpan[] spans = sp.getSpans(
spanStart, spanEnd, MetricAffectingSpan.class);
width += mt.addStyleRun(paint, spans, spanEnd - spanStart, null);
}
}
return width;
}
private static final char FIRST_RIGHT_TO_LEFT = '\u0590';
/* package */
static boolean doesNotNeedBidi(CharSequence s, int start, int end) {
for (int i = start; i < end; i++) {
if (s.charAt(i) >= FIRST_RIGHT_TO_LEFT) {
return false;
}
}
return true;
}
/* package */
static boolean doesNotNeedBidi(char[] text, int start, int len) {
for (int i = start, e = i + len; i < e; i++) {
if (text[i] >= FIRST_RIGHT_TO_LEFT) {
return false;
}
}
return true;
}
/* package */ static char[] obtain(int len) {
char[] buf;
synchronized (sLock) {
buf = sTemp;
sTemp = null;
}
if (buf == null || buf.length < len)
buf = new char[ArrayUtils.idealCharArraySize(len)];
return buf;
}
/* package */ static void recycle(char[] temp) {
if (temp.length > 1000)
return;
synchronized (sLock) {
sTemp = temp;
}
}
/**
* Html-encode the string.
* @param s the string to be encoded
* @return the encoded string
*/
public static String htmlEncode(String s) {
StringBuilder sb = new StringBuilder();
char c;
for (int i = 0; i < s.length(); i++) {
c = s.charAt(i);
switch (c) {
case '<':
sb.append("<"); //$NON-NLS-1$
break;
case '>':
sb.append(">"); //$NON-NLS-1$
break;
case '&':
sb.append("&"); //$NON-NLS-1$
break;
case '\'':
sb.append("'"); //$NON-NLS-1$
break;
case '"':
sb.append("""); //$NON-NLS-1$
break;
default:
sb.append(c);
}
}
return sb.toString();
}
/**
* Returns a CharSequence concatenating the specified CharSequences,
* retaining their spans if any.
*/
public static CharSequence concat(CharSequence... text) {
if (text.length == 0) {
return "";
}
if (text.length == 1) {
return text[0];
}
boolean spanned = false;
for (int i = 0; i < text.length; i++) {
if (text[i] instanceof Spanned) {
spanned = true;
break;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < text.length; i++) {
sb.append(text[i]);
}
if (!spanned) {
return sb.toString();
}
SpannableString ss = new SpannableString(sb);
int off = 0;
for (int i = 0; i < text.length; i++) {
int len = text[i].length();
if (text[i] instanceof Spanned) {
copySpansFrom((Spanned) text[i], 0, len, Object.class, ss, off);
}
off += len;
}
return new SpannedString(ss);
}
/**
* Returns whether the given CharSequence contains any printable characters.
*/
public static boolean isGraphic(CharSequence str) {
final int len = str.length();
for (int i=0; i