core/java/android/text/DynamicLayout.java - platform/frameworks/base - Gitiles

 /*
  * 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 android.graphics.Paint;
 import android.text.style.UpdateLayout;
 import android.text.style.WrapTogetherSpan;

 import java.lang.ref.WeakReference;

 /**
  * DynamicLayout is a text layout that updates itself as the text is edited.
  * <p>This is used by widgets to control text layout. You should not need
  * to use this class directly unless you are implementing your own widget
  * or custom display object, or need to call
  * {@link android.graphics.Canvas#drawText(java.lang.CharSequence, int, int, float, float, android.graphics.Paint)
  *  Canvas.drawText()} directly.</p>
  */
 public class DynamicLayout
 extends Layout
 {
     private static final int PRIORITY = 128;

     /**
      * Make a layout for the specified text that will be updated as
      * the text is changed.
      */
     public DynamicLayout(CharSequence base,
                          TextPaint paint,
                          int width, Alignment align,
                          float spacingmult, float spacingadd,
                          boolean includepad) {
         this(base, base, paint, width, align, spacingmult, spacingadd,
              includepad);
     }

     /**
      * Make a layout for the transformed text (password transformation
      * being the primary example of a transformation)
      * that will be updated as the base text is changed.
      */
     public DynamicLayout(CharSequence base, CharSequence display,
                          TextPaint paint,
                          int width, Alignment align,
                          float spacingmult, float spacingadd,
                          boolean includepad) {
         this(base, display, paint, width, align, spacingmult, spacingadd,
              includepad, null, 0);
     }

     /**
      * Make a layout for the transformed text (password transformation
      * being the primary example of a transformation)
      * that will be updated as the base text is changed.
      * If ellipsize is non-null, the Layout will ellipsize the text
      * down to ellipsizedWidth.
      */
     public DynamicLayout(CharSequence base, CharSequence display,
                          TextPaint paint,
                          int width, Alignment align,
                          float spacingmult, float spacingadd,
                          boolean includepad,
                          TextUtils.TruncateAt ellipsize, int ellipsizedWidth) {
         super((ellipsize == null)
                 ? display
                 : (display instanceof Spanned)
                     ? new SpannedEllipsizer(display)
                     : new Ellipsizer(display),
               paint, width, align, spacingmult, spacingadd);

         mBase = base;
         mDisplay = display;

         if (ellipsize != null) {
             mInts = new PackedIntVector(COLUMNS_ELLIPSIZE);
             mEllipsizedWidth = ellipsizedWidth;
             mEllipsizeAt = ellipsize;
         } else {
             mInts = new PackedIntVector(COLUMNS_NORMAL);
             mEllipsizedWidth = width;
             mEllipsizeAt = ellipsize;
         }

         mObjects = new PackedObjectVector<Directions>(1);

         mIncludePad = includepad;

         /*
          * This is annoying, but we can't refer to the layout until
          * superclass construction is finished, and the superclass
          * constructor wants the reference to the display text.
          *
          * This will break if the superclass constructor ever actually
          * cares about the content instead of just holding the reference.
          */
         if (ellipsize != null) {
             Ellipsizer e = (Ellipsizer) getText();

             e.mLayout = this;
             e.mWidth = ellipsizedWidth;
             e.mMethod = ellipsize;
             mEllipsize = true;
         }

         // Initial state is a single line with 0 characters (0 to 0),
         // with top at 0 and bottom at whatever is natural, and
         // undefined ellipsis.

         int[] start;

         if (ellipsize != null) {
             start = new int[COLUMNS_ELLIPSIZE];
             start[ELLIPSIS_START] = ELLIPSIS_UNDEFINED;
         } else {
             start = new int[COLUMNS_NORMAL];
         }

         Directions[] dirs = new Directions[] { DIRS_ALL_LEFT_TO_RIGHT };

         Paint.FontMetricsInt fm = paint.getFontMetricsInt();
         int asc = fm.ascent;
         int desc = fm.descent;

         start[DIR] = DIR_LEFT_TO_RIGHT << DIR_SHIFT;
         start[TOP] = 0;
         start[DESCENT] = desc;
         mInts.insertAt(0, start);

         start[TOP] = desc - asc;
         mInts.insertAt(1, start);

         mObjects.insertAt(0, dirs);

         // Update from 0 characters to whatever the real text is

         reflow(base, 0, 0, base.length());

         if (base instanceof Spannable) {
             if (mWatcher == null)
                 mWatcher = new ChangeWatcher(this);

             // Strip out any watchers for other DynamicLayouts.
             Spannable sp = (Spannable) base;
             ChangeWatcher[] spans = sp.getSpans(0, sp.length(), ChangeWatcher.class);
             for (int i = 0; i < spans.length; i++)
                 sp.removeSpan(spans[i]);

             sp.setSpan(mWatcher, 0, base.length(),
                        Spannable.SPAN_INCLUSIVE_INCLUSIVE |
                        (PRIORITY << Spannable.SPAN_PRIORITY_SHIFT));
         }
     }

     private void reflow(CharSequence s, int where, int before, int after) {
         if (s != mBase)
             return;

         CharSequence text = mDisplay;
         int len = text.length();

         // seek back to the start of the paragraph

         int find = TextUtils.lastIndexOf(text, '\n', where - 1);
         if (find < 0)
             find = 0;
         else
             find = find + 1;

         {
             int diff = where - find;
             before += diff;
             after += diff;
             where -= diff;
         }

         // seek forward to the end of the paragraph

         int look = TextUtils.indexOf(text, '\n', where + after);
         if (look < 0)
             look = len;
         else
             look++; // we want the index after the \n

         int change = look - (where + after);
         before += change;
         after += change;

         // seek further out to cover anything that is forced to wrap together

         if (text instanceof Spanned) {
             Spanned sp = (Spanned) text;
             boolean again;

             do {
                 again = false;

                 Object[] force = sp.getSpans(where, where + after,
                                              WrapTogetherSpan.class);

                 for (int i = 0; i < force.length; i++) {
                     int st = sp.getSpanStart(force[i]);
                     int en = sp.getSpanEnd(force[i]);

                     if (st < where) {
                         again = true;

                         int diff = where - st;
                         before += diff;
                         after += diff;
                         where -= diff;
                     }

                     if (en > where + after) {
                         again = true;

                         int diff = en - (where + after);
                         before += diff;
                         after += diff;
                     }
                 }
             } while (again);
         }

         // find affected region of old layout

         int startline = getLineForOffset(where);
         int startv = getLineTop(startline);

         int endline = getLineForOffset(where + before);
         if (where + after == len)
             endline = getLineCount();
         int endv = getLineTop(endline);
         boolean islast = (endline == getLineCount());

         // generate new layout for affected text

         StaticLayout reflowed;

         synchronized (sLock) {
             reflowed = sStaticLayout;
             sStaticLayout = null;
         }

         if (reflowed == null)
             reflowed = new StaticLayout(true);

         reflowed.generate(text, where, where + after,
                                       getPaint(), getWidth(), getAlignment(),
                                       getSpacingMultiplier(), getSpacingAdd(),
                                       false, true, mEllipsize,
                                       mEllipsizedWidth, mEllipsizeAt);
         int n = reflowed.getLineCount();

         // If the new layout has a blank line at the end, but it is not
         // the very end of the buffer, then we already have a line that
         // starts there, so disregard the blank line.

         if (where + after != len &&
             reflowed.getLineStart(n - 1) == where + after)
             n--;

         // remove affected lines from old layout

         mInts.deleteAt(startline, endline - startline);
         mObjects.deleteAt(startline, endline - startline);

         // adjust offsets in layout for new height and offsets

         int ht = reflowed.getLineTop(n);
         int toppad = 0, botpad = 0;

         if (mIncludePad && startline == 0) {
             toppad = reflowed.getTopPadding();
             mTopPadding = toppad;
             ht -= toppad;
         }
         if (mIncludePad && islast) {
             botpad = reflowed.getBottomPadding();
             mBottomPadding = botpad;
             ht += botpad;
         }

         mInts.adjustValuesBelow(startline, START, after - before);
         mInts.adjustValuesBelow(startline, TOP, startv - endv + ht);

         // insert new layout

         int[] ints;

         if (mEllipsize) {
             ints = new int[COLUMNS_ELLIPSIZE];
             ints[ELLIPSIS_START] = ELLIPSIS_UNDEFINED;
         } else {
             ints = new int[COLUMNS_NORMAL];
         }

         Directions[] objects = new Directions[1];


         for (int i = 0; i < n; i++) {
             ints[START] = reflowed.getLineStart(i) |
                           (reflowed.getParagraphDirection(i) << DIR_SHIFT) |
                           (reflowed.getLineContainsTab(i) ? TAB_MASK : 0);

             int top = reflowed.getLineTop(i) + startv;
             if (i > 0)
                 top -= toppad;
             ints[TOP] = top;

             int desc = reflowed.getLineDescent(i);
             if (i == n - 1)
                 desc += botpad;

             ints[DESCENT] = desc;
             objects[0] = reflowed.getLineDirections(i);

             if (mEllipsize) {
                 ints[ELLIPSIS_START] = reflowed.getEllipsisStart(i);
                 ints[ELLIPSIS_COUNT] = reflowed.getEllipsisCount(i);
             }

             mInts.insertAt(startline + i, ints);
             mObjects.insertAt(startline + i, objects);
         }

         synchronized (sLock) {
             sStaticLayout = reflowed;
         }
     }

     private void dump(boolean show) {
         int n = getLineCount();

         for (int i = 0; i < n; i++) {
             System.out.print("line " + i + ": " + getLineStart(i) + " to " + getLineEnd(i) + " ");

             if (show) {
                 System.out.print(getText().subSequence(getLineStart(i),
                                                        getLineEnd(i)));
             }

             System.out.println("");
         }

         System.out.println("");
     }

     public int getLineCount() {
         return mInts.size() - 1;
     }

     public int getLineTop(int line) {
         return mInts.getValue(line, TOP);
     }

     public int getLineDescent(int line) {
         return mInts.getValue(line, DESCENT);
     }

     public int getLineStart(int line) {
         return mInts.getValue(line, START) & START_MASK;
     }

     public boolean getLineContainsTab(int line) {
         return (mInts.getValue(line, TAB) & TAB_MASK) != 0;
     }

     public int getParagraphDirection(int line) {
         return mInts.getValue(line, DIR) >> DIR_SHIFT;
     }

     public final Directions getLineDirections(int line) {
         return mObjects.getValue(line, 0);
     }

     public int getTopPadding() {
         return mTopPadding;
     }

     public int getBottomPadding() {
         return mBottomPadding;
     }

     @Override
     public int getEllipsizedWidth() {
         return mEllipsizedWidth;
     }

     private static class ChangeWatcher
     implements TextWatcher, SpanWatcher
     {
         public ChangeWatcher(DynamicLayout layout) {
             mLayout = new WeakReference(layout);
         }

         private void reflow(CharSequence s, int where, int before, int after) {
             DynamicLayout ml = (DynamicLayout) mLayout.get();

             if (ml != null)
                 ml.reflow(s, where, before, after);
             else if (s instanceof Spannable)
                 ((Spannable) s).removeSpan(this);
         }

         public void beforeTextChanged(CharSequence s,
                                       int where, int before, int after) {
             ;
         }

         public void onTextChanged(CharSequence s,
                                   int where, int before, int after) {
             reflow(s, where, before, after);
         }

         public void afterTextChanged(Editable s) {
             ;
         }

         public void onSpanAdded(Spannable s, Object o, int start, int end) {
             if (o instanceof UpdateLayout)
                 reflow(s, start, end - start, end - start);
         }

         public void onSpanRemoved(Spannable s, Object o, int start, int end) {
             if (o instanceof UpdateLayout)
                 reflow(s, start, end - start, end - start);
         }

         public void onSpanChanged(Spannable s, Object o, int start, int end,
                                   int nstart, int nend) {
             if (o instanceof UpdateLayout) {
                 reflow(s, start, end - start, end - start);
                 reflow(s, nstart, nend - nstart, nend - nstart);
             }
         }

         private WeakReference mLayout;
     }

     public int getEllipsisStart(int line) {
         if (mEllipsizeAt == null) {
             return 0;
         }

         return mInts.getValue(line, ELLIPSIS_START);
     }

     public int getEllipsisCount(int line) {
         if (mEllipsizeAt == null) {
             return 0;
         }

         return mInts.getValue(line, ELLIPSIS_COUNT);
     }

     private CharSequence mBase;
     private CharSequence mDisplay;
     private ChangeWatcher mWatcher;
     private boolean mIncludePad;
     private boolean mEllipsize;
     private int mEllipsizedWidth;
     private TextUtils.TruncateAt mEllipsizeAt;

     private PackedIntVector mInts;
     private PackedObjectVector<Directions> mObjects;

     private int mTopPadding, mBottomPadding;

     private static StaticLayout sStaticLayout = new StaticLayout(true);
     private static Object sLock = new Object();

     private static final int START = 0;
     private static final int DIR = START;
     private static final int TAB = START;
     private static final int TOP = 1;
     private static final int DESCENT = 2;
     private static final int COLUMNS_NORMAL = 3;

     private static final int ELLIPSIS_START = 3;
     private static final int ELLIPSIS_COUNT = 4;
     private static final int COLUMNS_ELLIPSIZE = 5;

     private static final int START_MASK = 0x1FFFFFFF;
     private static final int DIR_MASK   = 0xC0000000;
     private static final int DIR_SHIFT  = 30;
     private static final int TAB_MASK   = 0x20000000;

     private static final int ELLIPSIS_UNDEFINED = 0x80000000;
 }
	/*
	* 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 android.graphics.Paint;
	import android.text.style.UpdateLayout;
	import android.text.style.WrapTogetherSpan;

	import java.lang.ref.WeakReference;

	/**
	* DynamicLayout is a text layout that updates itself as the text is edited.
	* <p>This is used by widgets to control text layout. You should not need
	* to use this class directly unless you are implementing your own widget
	* or custom display object, or need to call
	* {@link android.graphics.Canvas#drawText(java.lang.CharSequence, int, int, float, float, android.graphics.Paint)
	* Canvas.drawText()} directly.</p>
	*/
	public class DynamicLayout
	extends Layout
	{
	private static final int PRIORITY = 128;

	/**
	* Make a layout for the specified text that will be updated as
	* the text is changed.
	*/
	public DynamicLayout(CharSequence base,
	TextPaint paint,
	int width, Alignment align,
	float spacingmult, float spacingadd,
	boolean includepad) {
	this(base, base, paint, width, align, spacingmult, spacingadd,
	includepad);
	}

	/**
	* Make a layout for the transformed text (password transformation
	* being the primary example of a transformation)
	* that will be updated as the base text is changed.
	*/
	public DynamicLayout(CharSequence base, CharSequence display,
	TextPaint paint,
	int width, Alignment align,
	float spacingmult, float spacingadd,
	boolean includepad) {
	this(base, display, paint, width, align, spacingmult, spacingadd,
	includepad, null, 0);
	}

	/**
	* Make a layout for the transformed text (password transformation
	* being the primary example of a transformation)
	* that will be updated as the base text is changed.
	* If ellipsize is non-null, the Layout will ellipsize the text
	* down to ellipsizedWidth.
	*/
	public DynamicLayout(CharSequence base, CharSequence display,
	TextPaint paint,
	int width, Alignment align,
	float spacingmult, float spacingadd,
	boolean includepad,
	TextUtils.TruncateAt ellipsize, int ellipsizedWidth) {
	super((ellipsize == null)
	? display
	: (display instanceof Spanned)
	? new SpannedEllipsizer(display)
	: new Ellipsizer(display),
	paint, width, align, spacingmult, spacingadd);

	mBase = base;
	mDisplay = display;

	if (ellipsize != null) {
	mInts = new PackedIntVector(COLUMNS_ELLIPSIZE);
	mEllipsizedWidth = ellipsizedWidth;
	mEllipsizeAt = ellipsize;
	} else {
	mInts = new PackedIntVector(COLUMNS_NORMAL);
	mEllipsizedWidth = width;
	mEllipsizeAt = ellipsize;
	}

	mObjects = new PackedObjectVector<Directions>(1);

	mIncludePad = includepad;

	/*
	* This is annoying, but we can't refer to the layout until
	* superclass construction is finished, and the superclass
	* constructor wants the reference to the display text.
	*
	* This will break if the superclass constructor ever actually
	* cares about the content instead of just holding the reference.
	*/
	if (ellipsize != null) {
	Ellipsizer e = (Ellipsizer) getText();

	e.mLayout = this;
	e.mWidth = ellipsizedWidth;
	e.mMethod = ellipsize;
	mEllipsize = true;
	}

	// Initial state is a single line with 0 characters (0 to 0),
	// with top at 0 and bottom at whatever is natural, and
	// undefined ellipsis.

	int[] start;

	if (ellipsize != null) {
	start = new int[COLUMNS_ELLIPSIZE];
	start[ELLIPSIS_START] = ELLIPSIS_UNDEFINED;
	} else {
	start = new int[COLUMNS_NORMAL];
	}

	Directions[] dirs = new Directions[] { DIRS_ALL_LEFT_TO_RIGHT };

	Paint.FontMetricsInt fm = paint.getFontMetricsInt();
	int asc = fm.ascent;
	int desc = fm.descent;

	start[DIR] = DIR_LEFT_TO_RIGHT << DIR_SHIFT;
	start[TOP] = 0;
	start[DESCENT] = desc;
	mInts.insertAt(0, start);

	start[TOP] = desc - asc;
	mInts.insertAt(1, start);

	mObjects.insertAt(0, dirs);

	// Update from 0 characters to whatever the real text is

	reflow(base, 0, 0, base.length());

	if (base instanceof Spannable) {
	if (mWatcher == null)
	mWatcher = new ChangeWatcher(this);

	// Strip out any watchers for other DynamicLayouts.
	Spannable sp = (Spannable) base;
	ChangeWatcher[] spans = sp.getSpans(0, sp.length(), ChangeWatcher.class);
	for (int i = 0; i < spans.length; i++)
	sp.removeSpan(spans[i]);

	sp.setSpan(mWatcher, 0, base.length(),
	Spannable.SPAN_INCLUSIVE_INCLUSIVE \|
	(PRIORITY << Spannable.SPAN_PRIORITY_SHIFT));
	}
	}

	private void reflow(CharSequence s, int where, int before, int after) {
	if (s != mBase)
	return;

	CharSequence text = mDisplay;
	int len = text.length();

	// seek back to the start of the paragraph

	int find = TextUtils.lastIndexOf(text, '\n', where - 1);
	if (find < 0)
	find = 0;
	else
	find = find + 1;

	{
	int diff = where - find;
	before += diff;
	after += diff;
	where -= diff;
	}

	// seek forward to the end of the paragraph

	int look = TextUtils.indexOf(text, '\n', where + after);
	if (look < 0)
	look = len;
	else
	look++; // we want the index after the \n

	int change = look - (where + after);
	before += change;
	after += change;

	// seek further out to cover anything that is forced to wrap together

	if (text instanceof Spanned) {
	Spanned sp = (Spanned) text;
	boolean again;

	do {
	again = false;

	Object[] force = sp.getSpans(where, where + after,
	WrapTogetherSpan.class);

	for (int i = 0; i < force.length; i++) {
	int st = sp.getSpanStart(force[i]);
	int en = sp.getSpanEnd(force[i]);

	if (st < where) {
	again = true;

	int diff = where - st;
	before += diff;
	after += diff;
	where -= diff;
	}

	if (en > where + after) {
	again = true;

	int diff = en - (where + after);
	before += diff;
	after += diff;
	}
	}
	} while (again);
	}

	// find affected region of old layout

	int startline = getLineForOffset(where);
	int startv = getLineTop(startline);

	int endline = getLineForOffset(where + before);
	if (where + after == len)
	endline = getLineCount();
	int endv = getLineTop(endline);
	boolean islast = (endline == getLineCount());

	// generate new layout for affected text

	StaticLayout reflowed;

	synchronized (sLock) {
	reflowed = sStaticLayout;
	sStaticLayout = null;
	}

	if (reflowed == null)
	reflowed = new StaticLayout(true);

	reflowed.generate(text, where, where + after,
	getPaint(), getWidth(), getAlignment(),
	getSpacingMultiplier(), getSpacingAdd(),
	false, true, mEllipsize,
	mEllipsizedWidth, mEllipsizeAt);
	int n = reflowed.getLineCount();

	// If the new layout has a blank line at the end, but it is not
	// the very end of the buffer, then we already have a line that
	// starts there, so disregard the blank line.

	if (where + after != len &&
	reflowed.getLineStart(n - 1) == where + after)
	n--;

	// remove affected lines from old layout

	mInts.deleteAt(startline, endline - startline);
	mObjects.deleteAt(startline, endline - startline);

	// adjust offsets in layout for new height and offsets

	int ht = reflowed.getLineTop(n);
	int toppad = 0, botpad = 0;

	if (mIncludePad && startline == 0) {
	toppad = reflowed.getTopPadding();
	mTopPadding = toppad;
	ht -= toppad;
	}
	if (mIncludePad && islast) {
	botpad = reflowed.getBottomPadding();
	mBottomPadding = botpad;
	ht += botpad;
	}

	mInts.adjustValuesBelow(startline, START, after - before);
	mInts.adjustValuesBelow(startline, TOP, startv - endv + ht);

	// insert new layout

	int[] ints;

	if (mEllipsize) {
	ints = new int[COLUMNS_ELLIPSIZE];
	ints[ELLIPSIS_START] = ELLIPSIS_UNDEFINED;
	} else {
	ints = new int[COLUMNS_NORMAL];
	}

	Directions[] objects = new Directions[1];


	for (int i = 0; i < n; i++) {
	ints[START] = reflowed.getLineStart(i) \|
	(reflowed.getParagraphDirection(i) << DIR_SHIFT) \|
	(reflowed.getLineContainsTab(i) ? TAB_MASK : 0);

	int top = reflowed.getLineTop(i) + startv;
	if (i > 0)
	top -= toppad;
	ints[TOP] = top;

	int desc = reflowed.getLineDescent(i);
	if (i == n - 1)
	desc += botpad;

	ints[DESCENT] = desc;
	objects[0] = reflowed.getLineDirections(i);

	if (mEllipsize) {
	ints[ELLIPSIS_START] = reflowed.getEllipsisStart(i);
	ints[ELLIPSIS_COUNT] = reflowed.getEllipsisCount(i);
	}

	mInts.insertAt(startline + i, ints);
	mObjects.insertAt(startline + i, objects);
	}

	synchronized (sLock) {
	sStaticLayout = reflowed;
	}
	}

	private void dump(boolean show) {
	int n = getLineCount();

	for (int i = 0; i < n; i++) {
	System.out.print("line " + i + ": " + getLineStart(i) + " to " + getLineEnd(i) + " ");

	if (show) {
	System.out.print(getText().subSequence(getLineStart(i),
	getLineEnd(i)));
	}

	System.out.println("");
	}

	System.out.println("");
	}

	public int getLineCount() {
	return mInts.size() - 1;
	}

	public int getLineTop(int line) {
	return mInts.getValue(line, TOP);
	}

	public int getLineDescent(int line) {
	return mInts.getValue(line, DESCENT);
	}

	public int getLineStart(int line) {
	return mInts.getValue(line, START) & START_MASK;
	}

	public boolean getLineContainsTab(int line) {
	return (mInts.getValue(line, TAB) & TAB_MASK) != 0;
	}

	public int getParagraphDirection(int line) {
	return mInts.getValue(line, DIR) >> DIR_SHIFT;
	}

	public final Directions getLineDirections(int line) {
	return mObjects.getValue(line, 0);
	}

	public int getTopPadding() {
	return mTopPadding;
	}

	public int getBottomPadding() {
	return mBottomPadding;
	}

	@Override
	public int getEllipsizedWidth() {
	return mEllipsizedWidth;
	}

	private static class ChangeWatcher
	implements TextWatcher, SpanWatcher
	{
	public ChangeWatcher(DynamicLayout layout) {
	mLayout = new WeakReference(layout);
	}

	private void reflow(CharSequence s, int where, int before, int after) {
	DynamicLayout ml = (DynamicLayout) mLayout.get();

	if (ml != null)
	ml.reflow(s, where, before, after);
	else if (s instanceof Spannable)
	((Spannable) s).removeSpan(this);
	}

	public void beforeTextChanged(CharSequence s,
	int where, int before, int after) {
	;
	}

	public void onTextChanged(CharSequence s,
	int where, int before, int after) {
	reflow(s, where, before, after);
	}

	public void afterTextChanged(Editable s) {
	;
	}

	public void onSpanAdded(Spannable s, Object o, int start, int end) {
	if (o instanceof UpdateLayout)
	reflow(s, start, end - start, end - start);
	}

	public void onSpanRemoved(Spannable s, Object o, int start, int end) {
	if (o instanceof UpdateLayout)
	reflow(s, start, end - start, end - start);
	}

	public void onSpanChanged(Spannable s, Object o, int start, int end,
	int nstart, int nend) {
	if (o instanceof UpdateLayout) {
	reflow(s, start, end - start, end - start);
	reflow(s, nstart, nend - nstart, nend - nstart);
	}
	}

	private WeakReference mLayout;
	}

	public int getEllipsisStart(int line) {
	if (mEllipsizeAt == null) {
	return 0;
	}

	return mInts.getValue(line, ELLIPSIS_START);
	}

	public int getEllipsisCount(int line) {
	if (mEllipsizeAt == null) {
	return 0;
	}

	return mInts.getValue(line, ELLIPSIS_COUNT);
	}

	private CharSequence mBase;
	private CharSequence mDisplay;
	private ChangeWatcher mWatcher;
	private boolean mIncludePad;
	private boolean mEllipsize;
	private int mEllipsizedWidth;
	private TextUtils.TruncateAt mEllipsizeAt;

	private PackedIntVector mInts;
	private PackedObjectVector<Directions> mObjects;

	private int mTopPadding, mBottomPadding;

	private static StaticLayout sStaticLayout = new StaticLayout(true);
	private static Object sLock = new Object();

	private static final int START = 0;
	private static final int DIR = START;
	private static final int TAB = START;
	private static final int TOP = 1;
	private static final int DESCENT = 2;
	private static final int COLUMNS_NORMAL = 3;

	private static final int ELLIPSIS_START = 3;
	private static final int ELLIPSIS_COUNT = 4;
	private static final int COLUMNS_ELLIPSIZE = 5;

	private static final int START_MASK = 0x1FFFFFFF;
	private static final int DIR_MASK = 0xC0000000;
	private static final int DIR_SHIFT = 30;
	private static final int TAB_MASK = 0x20000000;

	private static final int ELLIPSIS_UNDEFINED = 0x80000000;
	}