public override bool requestChildRectangleOnScreen(android.view.View child, android.graphics.Rect
rectangle, bool immediate)
{
// offset into coordinate space of this scroll view
rectangle.offset(child.getLeft() - child.getScrollX(), child.getTop() - child.getScrollY
());
return scrollToChildRect(rectangle, immediate);
}
/// <summary><p>Positions the popup window on screen.</summary>
/// <remarks>
/// <p>Positions the popup window on screen. When the popup window is too
/// tall to fit under the anchor, a parent scroll view is seeked and scrolled
/// up to reclaim space. If scrolling is not possible or not enough, the
/// popup window gets moved on top of the anchor.</p>
/// <p>The height must have been set on the layout parameters prior to
/// calling this method.</p>
/// </remarks>
/// <param name="anchor">the view on which the popup window must be anchored</param>
/// <param name="p">the layout parameters used to display the drop down</param>
/// <returns>true if the popup is translated upwards to fit on screen</returns>
private bool findDropDownPosition(android.view.View anchor, android.view.WindowManagerClass
.LayoutParams p, int xoff, int yoff)
{
int anchorHeight = anchor.getHeight();
anchor.getLocationInWindow(mDrawingLocation);
p.x = mDrawingLocation[0] + xoff;
p.y = mDrawingLocation[1] + anchorHeight + yoff;
bool onTop = false;
p.gravity = android.view.Gravity.LEFT | android.view.Gravity.TOP;
anchor.getLocationOnScreen(mScreenLocation);
android.graphics.Rect displayFrame = new android.graphics.Rect();
anchor.getWindowVisibleDisplayFrame(displayFrame);
int screenY = mScreenLocation[1] + anchorHeight + yoff;
android.view.View root = anchor.getRootView();
if (screenY + mPopupHeight > displayFrame.bottom || p.x + mPopupWidth - root.getWidth
() > 0)
{
// if the drop down disappears at the bottom of the screen. we try to
// scroll a parent scrollview or move the drop down back up on top of
// the edit box
if (mAllowScrollingAnchorParent)
{
int scrollX = anchor.getScrollX();
int scrollY = anchor.getScrollY();
android.graphics.Rect r = new android.graphics.Rect(scrollX, scrollY, scrollX + mPopupWidth
+ xoff, scrollY + mPopupHeight + anchor.getHeight() + yoff);
anchor.requestRectangleOnScreen(r, true);
}
// now we re-evaluate the space available, and decide from that
// whether the pop-up will go above or below the anchor.
anchor.getLocationInWindow(mDrawingLocation);
p.x = mDrawingLocation[0] + xoff;
p.y = mDrawingLocation[1] + anchor.getHeight() + yoff;
// determine whether there is more space above or below the anchor
anchor.getLocationOnScreen(mScreenLocation);
onTop = (displayFrame.bottom - mScreenLocation[1] - anchor.getHeight() - yoff) <
(mScreenLocation[1] - yoff - displayFrame.top);
if (onTop)
{
p.gravity = android.view.Gravity.LEFT | android.view.Gravity.BOTTOM;
p.y = root.getHeight() - mDrawingLocation[1] + yoff;
}
else
{
p.y = mDrawingLocation[1] + anchor.getHeight() + yoff;
}
}
if (mClipToScreen)
{
int displayFrameWidth = displayFrame.right - displayFrame.left;
int right = p.x + p.width;
if (right > displayFrameWidth)
{
p.x -= right - displayFrameWidth;
}
if (p.x < displayFrame.left)
{
p.x = displayFrame.left;
p.width = System.Math.Min(p.width, displayFrameWidth);
}
if (onTop)
{
int popupTop = mScreenLocation[1] + yoff - mPopupHeight;
if (popupTop < 0)
{
p.y += popupTop;
}
}
else
{
p.y = System.Math.Max(p.y, displayFrame.top);
}
}
p.gravity |= android.view.Gravity.DISPLAY_CLIP_VERTICAL;
return onTop;
}
/// <summary>Performs a scroll to line end action.</summary>
/// <remarks>
/// Performs a scroll to line end action.
/// Scrolls to the end of the line.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollLineEnd(android.widget.TextView widget, android.text.Spannable
buffer)
{
int maxScrollX = getScrollBoundsRight(widget) - getInnerWidth(widget);
int scrollX = widget.getScrollX();
if (scrollX < maxScrollX)
{
widget.scrollTo(maxScrollX, widget.getScrollY());
return true;
}
return false;
}
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>Performs a scroll page up action.</summary>
/// <remarks>
/// Performs a scroll page up action.
/// Scrolls down by one page.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollPageDown(android.widget.TextView widget, android.text.Spannable
buffer)
{
android.text.Layout layout = widget.getLayout();
int innerHeight = getInnerHeight(widget);
int bottom_1 = widget.getScrollY() + innerHeight + innerHeight;
int bottomLine = layout.getLineForVertical(bottom_1);
if (bottomLine <= layout.getLineCount() - 1)
{
android.text.method.Touch.scrollTo(widget, layout, widget.getScrollX(), layout.getLineTop
(bottomLine + 1) - innerHeight);
return true;
}
return false;
}
/// <summary>Performs a scroll to line start action.</summary>
/// <remarks>
/// Performs a scroll to line start action.
/// Scrolls to the start of the line.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollLineStart(android.widget.TextView widget, android.text.Spannable
buffer)
{
int minScrollX = getScrollBoundsLeft(widget);
int scrollX = widget.getScrollX();
if (scrollX > minScrollX)
{
widget.scrollTo(minScrollX, widget.getScrollY());
return true;
}
return false;
}
/// <summary>Performs a scroll down action.</summary>
/// <remarks>
/// Performs a scroll down action.
/// Scrolls down by the specified number of lines.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <param name="amount">The number of lines to scroll by. Must be at least 1.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollDown(android.widget.TextView widget, android.text.Spannable
buffer, int amount)
{
android.text.Layout layout = widget.getLayout();
int innerHeight = getInnerHeight(widget);
int bottom_1 = widget.getScrollY() + innerHeight;
int bottomLine = layout.getLineForVertical(bottom_1);
if (layout.getLineTop(bottomLine + 1) < bottom_1 + 1)
{
// Less than a pixel of this line is out of view,
// so we must have tried to make it entirely in view
// and now want the next line to be in view instead.
bottomLine += 1;
}
int limit = layout.getLineCount() - 1;
if (bottomLine <= limit)
{
bottomLine = System.Math.Min(bottomLine + amount - 1, limit);
android.text.method.Touch.scrollTo(widget, layout, widget.getScrollX(), layout.getLineTop
(bottomLine + 1) - innerHeight);
return true;
}
return false;
}
/// <summary>Performs a scroll page up action.</summary>
/// <remarks>
/// Performs a scroll page up action.
/// Scrolls up by one page.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollPageUp(android.widget.TextView widget, android.text.Spannable
buffer)
{
android.text.Layout layout = widget.getLayout();
int top_1 = widget.getScrollY() - getInnerHeight(widget);
int topLine = layout.getLineForVertical(top_1);
if (topLine >= 0)
{
android.text.method.Touch.scrollTo(widget, layout, widget.getScrollX(), layout.getLineTop
(topLine));
return true;
}
return false;
}
/// <summary>Performs a scroll up action.</summary>
/// <remarks>
/// Performs a scroll up action.
/// Scrolls up by the specified number of lines.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <param name="amount">The number of lines to scroll by. Must be at least 1.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollUp(android.widget.TextView widget, android.text.Spannable
buffer, int amount)
{
android.text.Layout layout = widget.getLayout();
int top_1 = widget.getScrollY();
int topLine = layout.getLineForVertical(top_1);
if (layout.getLineTop(topLine) == top_1)
{
// If the top line is partially visible, bring it all the way
// into view; otherwise, bring the previous line into view.
topLine -= 1;
}
if (topLine >= 0)
{
topLine = System.Math.Max(topLine - amount + 1, 0);
android.text.method.Touch.scrollTo(widget, layout, widget.getScrollX(), layout.getLineTop
(topLine));
return true;
}
return false;
}
/// <summary>Performs a scroll right action.</summary>
/// <remarks>
/// Performs a scroll right action.
/// Scrolls right by the specified number of characters.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <param name="amount">The number of characters to scroll by. Must be at least 1.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollRight(android.widget.TextView widget, android.text.Spannable
buffer, int amount)
{
int maxScrollX = getScrollBoundsRight(widget) - getInnerWidth(widget);
int scrollX = widget.getScrollX();
if (scrollX < maxScrollX)
{
scrollX = System.Math.Min(scrollX + getCharacterWidth(widget) * amount, maxScrollX
);
widget.scrollTo(scrollX, widget.getScrollY());
return true;
}
return false;
}
/// <summary>Performs a scroll left action.</summary>
/// <remarks>
/// Performs a scroll left action.
/// Scrolls left by the specified number of characters.
/// </remarks>
/// <param name="widget">The text view.</param>
/// <param name="buffer">The text buffer.</param>
/// <param name="amount">The number of characters to scroll by. Must be at least 1.</param>
/// <returns>True if the event was handled.</returns>
/// <hide></hide>
protected internal virtual bool scrollLeft(android.widget.TextView widget, android.text.Spannable
buffer, int amount)
{
int minScrollX = getScrollBoundsLeft(widget);
int scrollX = widget.getScrollX();
if (scrollX > minScrollX)
{
scrollX = System.Math.Max(scrollX - getCharacterWidth(widget) * amount, minScrollX
);
widget.scrollTo(scrollX, widget.getScrollY());
return true;
}
return false;
}
private int getBottomLine(android.widget.TextView widget)
{
return widget.getLayout().getLineForVertical(widget.getScrollY() + getInnerHeight
(widget));
}
private int getTopLine(android.widget.TextView widget)
{
return widget.getLayout().getLineForVertical(widget.getScrollY());
}