// These bits are privately used by the meta key key listener.
// They are deliberately assigned values outside of the representable range of an 'int'
// so as not to conflict with any meta key states publicly defined by KeyEvent.
/// <summary>Resets all meta state to inactive.</summary>
/// <remarks>Resets all meta state to inactive.</remarks>
public static void resetMetaState(android.text.Spannable text)
{
text.removeSpan(CAP);
text.removeSpan(ALT);
text.removeSpan(SYM);
text.removeSpan(SELECTING);
}
public virtual void onSpanChanged(android.text.Spannable s, object what, int start
, int end, int st, int en)
{
if (what == android.text.Selection.SELECTION_END)
{
s.removeSpan(ACTIVE);
}
}
private static void resetLock(android.text.Spannable content, object what)
{
int current = content.getSpanFlags(what);
if (current == LOCKED)
{
content.removeSpan(what);
}
}
private static void adjust(android.text.Spannable content, object what)
{
int current = content.getSpanFlags(what);
if (current == PRESSED)
{
content.setSpan(what, 0, 0, USED);
}
else
{
if (current == RELEASED)
{
content.removeSpan(what);
}
}
}
/// <summary>
/// Marks the specified region of <code>content</code> as having
/// contained <code>original</code> prior to AutoText replacement.
/// </summary>
/// <remarks>
/// Marks the specified region of <code>content</code> as having
/// contained <code>original</code> prior to AutoText replacement.
/// Call this method when you have done or are about to do an
/// AutoText-style replacement on a region of text and want to let
/// the same mechanism (the user pressing DEL immediately after the
/// change) undo the replacement.
/// </remarks>
/// <param name="content">the Editable text where the replacement was made</param>
/// <param name="start">the start of the replaced region</param>
/// <param name="end">the end of the replaced region; the location of the cursor</param>
/// <param name="original">the text to be restored if the user presses DEL</param>
public static void markAsReplaced(android.text.Spannable content, int start, int
end, string original)
{
android.text.method.QwertyKeyListener.Replaced[] repl = content.getSpans <android.text.method.QwertyKeyListener
.Replaced>(0, content.Length);
{
for (int a = 0; a < repl.Length; a++)
{
content.removeSpan(repl[a]);
}
}
int len = original.Length;
char[] orig = new char[len];
Sharpen.StringHelper.GetCharsForString(original, 0, len, orig, 0);
content.setSpan(new android.text.method.QwertyKeyListener.Replaced(orig), start,
end, android.text.SpannedClass.SPAN_EXCLUSIVE_EXCLUSIVE);
}
public override bool onTouchEvent(android.widget.TextView widget, android.text.Spannable
buffer, android.view.MotionEvent @event)
{
int initialScrollX = -1;
int initialScrollY = -1;
int action = @event.getAction();
if (action == android.view.MotionEvent.ACTION_UP)
{
initialScrollX = android.text.method.Touch.getInitialScrollX(widget, buffer);
initialScrollY = android.text.method.Touch.getInitialScrollY(widget, buffer);
}
bool handled = android.text.method.Touch.onTouchEvent(widget, buffer, @event);
if (widget.isFocused() && !widget.didTouchFocusSelect())
{
if (action == android.view.MotionEvent.ACTION_DOWN)
{
if (isSelecting(buffer))
{
int offset = widget.getOffsetForPosition(@event.getX(), @event.getY());
buffer.setSpan(LAST_TAP_DOWN, offset, offset, android.text.SpannedClass.SPAN_POINT_POINT
);
// Disallow intercepting of the touch events, so that
// users can scroll and select at the same time.
// without this, users would get booted out of select
// mode once the view detected it needed to scroll.
widget.getParent().requestDisallowInterceptTouchEvent(true);
}
}
else
{
if (action == android.view.MotionEvent.ACTION_MOVE)
{
if (isSelecting(buffer) && handled)
{
// Before selecting, make sure we've moved out of the "slop".
// handled will be true, if we're in select mode AND we're
// OUT of the slop
// Turn long press off while we're selecting. User needs to
// re-tap on the selection to enable long press
widget.cancelLongPress();
// Update selection as we're moving the selection area.
// Get the current touch position
int offset = widget.getOffsetForPosition(@event.getX(), @event.getY());
android.text.Selection.extendSelection(buffer, offset);
return(true);
}
}
else
{
if (action == android.view.MotionEvent.ACTION_UP)
{
// If we have scrolled, then the up shouldn't move the cursor,
// but we do need to make sure the cursor is still visible at
// the current scroll offset to avoid the scroll jumping later
// to show it.
if ((initialScrollY >= 0 && initialScrollY != widget.getScrollY()) || (initialScrollX
>= 0 && initialScrollX != widget.getScrollX()))
{
widget.moveCursorToVisibleOffset();
return(true);
}
int offset = widget.getOffsetForPosition(@event.getX(), @event.getY());
if (isSelecting(buffer))
{
buffer.removeSpan(LAST_TAP_DOWN);
android.text.Selection.extendSelection(buffer, offset);
}
else
{
if (!widget.shouldIgnoreActionUpEvent())
{
android.text.Selection.setSelection(buffer, offset);
}
}
android.text.method.MetaKeyKeyListener.adjustMetaAfterKeypress(buffer);
android.text.method.MetaKeyKeyListener.resetLockedMeta(buffer);
return(true);
}
}
}
}
return(handled);
}
/// <summary>
/// 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.
/// </summary>
/// <remarks>
/// 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.
/// *
/// *@hide
/// </remarks>
public DynamicLayout(java.lang.CharSequence @base, java.lang.CharSequence display
, android.text.TextPaint paint, int width, android.text.Layout.Alignment?align,
android.text.TextDirectionHeuristic textDir, float spacingmult, float spacingadd
, bool includepad, android.text.TextUtils.TruncateAt?ellipsize_1, int ellipsizedWidth
) : base((ellipsize_1 == null) ? display : (display is android.text.Spanned) ? new
android.text.Layout.SpannedEllipsizer(display) : new android.text.Layout.Ellipsizer
(display), paint, width, align, textDir, spacingmult, spacingadd)
{
mBase = @base;
mDisplay = display;
if (ellipsize_1 != null)
{
mInts = new android.text.PackedIntVector(COLUMNS_ELLIPSIZE);
mEllipsizedWidth = ellipsizedWidth;
mEllipsizeAt = ellipsize_1;
}
else
{
mInts = new android.text.PackedIntVector(COLUMNS_NORMAL);
mEllipsizedWidth = width;
mEllipsizeAt = null;
}
mObjects = new android.text.PackedObjectVector <android.text.Layout.Directions>(1);
mIncludePad = includepad;
if (ellipsize_1 != null)
{
android.text.Layout.Ellipsizer e = (android.text.Layout.Ellipsizer)getText();
e.mLayout = this;
e.mWidth = ellipsizedWidth;
e.mMethod = ellipsize_1;
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_1 != null)
{
start = new int[COLUMNS_ELLIPSIZE];
start[ELLIPSIS_START] = ELLIPSIS_UNDEFINED;
}
else
{
start = new int[COLUMNS_NORMAL];
}
android.text.Layout.Directions[] dirs = new android.text.Layout.Directions[] { DIRS_ALL_LEFT_TO_RIGHT };
android.graphics.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 is android.text.Spannable)
{
if (mWatcher == null)
{
mWatcher = new android.text.DynamicLayout.ChangeWatcher(this);
}
// Strip out any watchers for other DynamicLayouts.
android.text.Spannable sp = (android.text.Spannable)@base;
android.text.DynamicLayout.ChangeWatcher[] spans = sp.getSpans <android.text.DynamicLayout
.ChangeWatcher>(0, sp.Length);
{
for (int i = 0; i < spans.Length; i++)
{
sp.removeSpan(spans[i]);
}
}
sp.setSpan(mWatcher, 0, @base.Length, android.text.SpannedClass.SPAN_INCLUSIVE_INCLUSIVE
| (PRIORITY << android.text.SpannedClass.SPAN_PRIORITY_SHIFT));
}
}
/// <summary>Stop selecting text.</summary>
/// <remarks>
/// Stop selecting text. This does not actually collapse the selection;
/// call
/// <see cref="android.text.Selection.setSelection(android.text.Spannable, int)">android.text.Selection.setSelection(android.text.Spannable, int)
/// </see>
/// too.
/// </remarks>
/// <hide>pending API review</hide>
public static void stopSelecting(android.view.View view, android.text.Spannable content
)
{
content.removeSpan(SELECTING);
}
/// <summary>Remove the selection or cursor, if any, from the text.</summary>
/// <remarks>Remove the selection or cursor, if any, from the text.</remarks>
public static void removeSelection(android.text.Spannable text)
{
text.removeSpan(SELECTION_START);
text.removeSpan(SELECTION_END);
}