/*

 * 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.

 */

/*

 * Revised 5/19/2010 by GORGES

 * Now supports two-dimensional view scrolling

 * http://GORGES.us

 */

package com.freerdp.freerdpcore.presentation;

import android.content.Context;

import android.graphics.Rect;

import android.util.AttributeSet;

import android.view.FocusFinder;

import android.view.KeyEvent;

import android.view.MotionEvent;

import android.view.VelocityTracker;

import android.view.View;

import android.view.ViewConfiguration;

import android.view.ViewGroup;

import android.view.ViewParent;

import android.view.animation.AnimationUtils;

import android.widget.FrameLayout;

import android.widget.LinearLayout;

import android.widget.Scroller;

import android.widget.TextView;

import java.util.List;

/**

 * Layout container for a view hierarchy that can be scrolled by the user,

 * allowing it to be larger than the physical display.  A TwoDScrollView

 * is a {@link FrameLayout}, meaning you should place one child in it

 * containing the entire contents to scroll; this child may itself be a layout

 * manager with a complex hierarchy of objects.  A child that is often used

 * is a {@link LinearLayout} in a vertical orientation, presenting a vertical

 * array of top-level items that the user can scroll through.

 * 

 * 
The {@link TextView} class also

 * takes care of its own scrolling, so does not require a TwoDScrollView, but

 * using the two together is possible to achieve the effect of a text view

 * within a larger container.

 */

public class ScrollView2D extends FrameLayout

{

	static final int ANIMATED_SCROLL_GAP = 250;

	static final float MAX_SCROLL_FACTOR = 0.5f;

	private final Rect mTempRect = new Rect();

	private ScrollView2DListener scrollView2DListener = null;

	private long mLastScroll;

	private Scroller mScroller;

	private boolean scrollEnabled = true;

	/**

	 * Flag to indicate that we are moving focus ourselves. This is so the

	 * code that watches for focus changes initiated outside this TwoDScrollView

	 * knows that it does not have to do anything.

	 */

	private boolean mTwoDScrollViewMovedFocus;

	/**

	 * Position of the last motion event.

	 */

	private float mLastMotionY;

	private float mLastMotionX;

	/**

	 * True when the layout has changed but the traversal has not come through yet.

	 * Ideally the view hierarchy would keep track of this for us.

	 */

	private boolean mIsLayoutDirty = true;

	/**

	 * The child to give focus to in the event that a child has requested focus while the

	 * layout is dirty. This prevents the scroll from being wrong if the child has not been

	 * laid out before requesting focus.

	 */

	private View mChildToScrollTo = null;

	/**

	 * True if the user is currently dragging this TwoDScrollView around. This is

	 * not the same as 'is being flinged', which can be checked by

	 * mScroller.isFinished() (flinging begins when the user lifts his finger).

	 */

	private boolean mIsBeingDragged = false;

	/**

	 * Determines speed during touch scrolling

	 */

	private VelocityTracker mVelocityTracker;

	/**

	 * Whether arrow scrolling is animated.

	 */

	private int mTouchSlop;

	private int mMinimumVelocity;

	private int mMaximumVelocity;

	public ScrollView2D(Context context)

	{

		super(context);

		initTwoDScrollView();

	}

	public ScrollView2D(Context context, AttributeSet attrs)

	{

		super(context, attrs);

		initTwoDScrollView();

	}

	public ScrollView2D(Context context, AttributeSet attrs, int defStyle)

	{

		super(context, attrs, defStyle);

		initTwoDScrollView();

	}

	@Override protected float getTopFadingEdgeStrength()

	{

		if (getChildCount() == 0)

		{

			return 0.0f;

		}

		final int length = getVerticalFadingEdgeLength();

		if (getScrollY() < length)

		{

			return getScrollY() / (float)length;

		}

		return 1.0f;

	}

	@Override protected float getBottomFadingEdgeStrength()

	{

		if (getChildCount() == 0)

		{

			return 0.0f;

		}

		final int length = getVerticalFadingEdgeLength();

		final int bottomEdge = getHeight() - getPaddingBottom();

		final int span = getChildAt(0).getBottom() - getScrollY() - bottomEdge;

		if (span < length)

		{

			return span / (float)length;

		}

		return 1.0f;

	}

	@Override protected float getLeftFadingEdgeStrength()

	{

		if (getChildCount() == 0)

		{

			return 0.0f;

		}

		final int length = getHorizontalFadingEdgeLength();

		if (getScrollX() < length)

		{

			return getScrollX() / (float)length;

		}

		return 1.0f;

	}

	@Override protected float getRightFadingEdgeStrength()

	{

		if (getChildCount() == 0)

		{

			return 0.0f;

		}

		final int length = getHorizontalFadingEdgeLength();

		final int rightEdge = getWidth() - getPaddingRight();

		final int span = getChildAt(0).getRight() - getScrollX() - rightEdge;

		if (span < length)

		{

			return span / (float)length;

		}

		return 1.0f;

	}

	/**

	 * Disable/Enable scrolling

	 */

	public void setScrollEnabled(boolean enable)

	{

		scrollEnabled = enable;

	}

	/**

	 * @return The maximum amount this scroll view will scroll in response to

	 * an arrow event.

	 */

	public int getMaxScrollAmountVertical()

	{

		return (int)(MAX_SCROLL_FACTOR * getHeight());

	}

	public int getMaxScrollAmountHorizontal()

	{

		return (int)(MAX_SCROLL_FACTOR * getWidth());

	}

	private void initTwoDScrollView()

	{

		mScroller = new Scroller(getContext());

		setFocusable(true);

		setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);

		setWillNotDraw(false);

		final ViewConfiguration configuration = ViewConfiguration.get(getContext());

		mTouchSlop = configuration.getScaledTouchSlop();

		mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();

		mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();

	}

	@Override public void addView(View child)

	{

		if (getChildCount() > 0)

		{

			throw new IllegalStateException("TwoDScrollView can host only one direct child");

		}

		super.addView(child);

	}

	@Override public void addView(View child, int index)

	{

		if (getChildCount() > 0)

		{

			throw new IllegalStateException("TwoDScrollView can host only one direct child");

		}

		super.addView(child, index);

	}

	@Override public void addView(View child, ViewGroup.LayoutParams params)

	{

		if (getChildCount() > 0)

		{

			throw new IllegalStateException("TwoDScrollView can host only one direct child");

		}

		super.addView(child, params);

	}

	@Override public void addView(View child, int index, ViewGroup.LayoutParams params)

	{

		if (getChildCount() > 0)

		{

			throw new IllegalStateException("TwoDScrollView can host only one direct child");

		}

		super.addView(child, index, params);

	}

	/**

	 * @return Returns true this TwoDScrollView can be scrolled

	 */

	private boolean canScroll()

	{

		if (!scrollEnabled)

			return false;

		View child = getChildAt(0);

		if (child != null)

		{

			int childHeight = child.getHeight();

			int childWidth = child.getWidth();

			return (getHeight() < childHeight + getPaddingTop() + getPaddingBottom()) ||

			    (getWidth() < childWidth + getPaddingLeft() + getPaddingRight());

		}

		return false;

	}

	@Override public boolean dispatchKeyEvent(KeyEvent event)

	{

		// Let the focused view and/or our descendants get the key first

		boolean handled = super.dispatchKeyEvent(event);

		if (handled)

		{

			return true;

		}

		return executeKeyEvent(event);

	}

	/**

	 * You can call this function yourself to have the scroll view perform

	 * scrolling from a key event, just as if the event had been dispatched to

	 * it by the view hierarchy.

	 *

	 * @param event The key event to execute.

	 * @return Return true if the event was handled, else false.

	 */

	public boolean executeKeyEvent(KeyEvent event)

	{

		mTempRect.setEmpty();

		if (!canScroll())

		{

			if (isFocused())

			{

				View currentFocused = findFocus();

				if (currentFocused == this)

					currentFocused = null;

				View nextFocused =

				    FocusFinder.getInstance().findNextFocus(this, currentFocused, View.FOCUS_DOWN);

				return nextFocused != null && nextFocused != this &&

				    nextFocused.requestFocus(View.FOCUS_DOWN);

			}

			return false;

		}

		boolean handled = false;

		if (event.getAction() == KeyEvent.ACTION_DOWN)

		{

			switch (event.getKeyCode())

			{

				case KeyEvent.KEYCODE_DPAD_UP:

					if (!event.isAltPressed())

					{

						handled = arrowScroll(View.FOCUS_UP, false);

					}

					else

					{

						handled = fullScroll(View.FOCUS_UP, false);

					}

					break;

				case KeyEvent.KEYCODE_DPAD_DOWN:

					if (!event.isAltPressed())

					{

						handled = arrowScroll(View.FOCUS_DOWN, false);

					}

					else

					{

						handled = fullScroll(View.FOCUS_DOWN, false);

					}

					break;

				case KeyEvent.KEYCODE_DPAD_LEFT:

					if (!event.isAltPressed())

					{

						handled = arrowScroll(View.FOCUS_LEFT, true);

					}

					else

					{

						handled = fullScroll(View.FOCUS_LEFT, true);

					}

					break;

				case KeyEvent.KEYCODE_DPAD_RIGHT:

					if (!event.isAltPressed())

					{

						handled = arrowScroll(View.FOCUS_RIGHT, true);

					}

					else

					{

						handled = fullScroll(View.FOCUS_RIGHT, true);

					}

					break;

			}

		}

		return handled;

	}

	@Override public boolean onInterceptTouchEvent(MotionEvent ev)

	{

		/*

		 * This method JUST determines whether we want to intercept the motion.

		 * If we return true, onMotionEvent will be called and we do the actual

		 * scrolling there.

		 *

		 * Shortcut the most recurring case: the user is in the dragging

		 * state and he is moving his finger.  We want to intercept this

		 * motion.

		 */

		final int action = ev.getAction();

		if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged))

		{

			return true;

		}

		if (!canScroll())

		{

			mIsBeingDragged = false;

			return false;

		}

		final float y = ev.getY();

		final float x = ev.getX();

		switch (action)

		{

			case MotionEvent.ACTION_MOVE:

				/*

				 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check

				 * whether the user has moved far enough from his original down touch.

				 */

				/*

				 * Locally do absolute value. mLastMotionY is set to the y value

				 * of the down event.

				 */

				final int yDiff = (int)Math.abs(y - mLastMotionY);

				final int xDiff = (int)Math.abs(x - mLastMotionX);

				if (yDiff > mTouchSlop || xDiff > mTouchSlop)

				{

					mIsBeingDragged = true;

				}

				break;

			case MotionEvent.ACTION_DOWN:

				/* Remember location of down touch */

				mLastMotionY = y;

				mLastMotionX = x;

				/*

				 * If being flinged and user touches the screen, initiate drag;

				 * otherwise don't.  mScroller.isFinished should be false when

				 * being flinged.

				 */

				mIsBeingDragged = !mScroller.isFinished();

				break;

			case MotionEvent.ACTION_CANCEL:

			case MotionEvent.ACTION_UP:

				/* Release the drag */

				mIsBeingDragged = false;

				break;

		}

		/*

		 * The only time we want to intercept motion events is if we are in the

		 * drag mode.

		 */

		return mIsBeingDragged;

	}

	@Override public boolean onTouchEvent(MotionEvent ev)

	{

		if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0)

		{

			// Don't handle edge touches immediately -- they may actually belong to one of our

			// descendants.

			return false;

		}

		if (!canScroll())

		{

			return false;

		}

		if (mVelocityTracker == null)

		{

			mVelocityTracker = VelocityTracker.obtain();

		}

		mVelocityTracker.addMovement(ev);

		final int action = ev.getAction();

		final float y = ev.getY();

		final float x = ev.getX();

		switch (action)

		{

			case MotionEvent.ACTION_DOWN:

				/*

				 * If being flinged and user touches, stop the fling. isFinished

				 * will be false if being flinged.

				 */

				if (!mScroller.isFinished())

				{

					mScroller.abortAnimation();

				}

				// Remember where the motion event started

				mLastMotionY = y;

				mLastMotionX = x;

				break;

			case MotionEvent.ACTION_MOVE:

				// Scroll to follow the motion event

				int deltaX = (int)(mLastMotionX - x);

				int deltaY = (int)(mLastMotionY - y);

				mLastMotionX = x;

				mLastMotionY = y;

				if (deltaX < 0)

				{

					if (getScrollX() < 0)

					{

						deltaX = 0;

					}

				}

				else if (deltaX > 0)

				{

					final int rightEdge = getWidth() - getPaddingRight();

					final int availableToScroll =

					    getChildAt(0).getRight() - getScrollX() - rightEdge;

					if (availableToScroll > 0)

					{

						deltaX = Math.min(availableToScroll, deltaX);

					}

					else

					{

						deltaX = 0;

					}

				}

				if (deltaY < 0)

				{

					if (getScrollY() < 0)

					{

						deltaY = 0;

					}

				}

				else if (deltaY > 0)

				{

					final int bottomEdge = getHeight() - getPaddingBottom();

					final int availableToScroll =

					    getChildAt(0).getBottom() - getScrollY() - bottomEdge;

					if (availableToScroll > 0)

					{

						deltaY = Math.min(availableToScroll, deltaY);

					}

					else

					{

						deltaY = 0;

					}

				}

				if (deltaY != 0 || deltaX != 0)

					scrollBy(deltaX, deltaY);

				break;

			case MotionEvent.ACTION_UP:

				final VelocityTracker velocityTracker = mVelocityTracker;

				velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);

				int initialXVelocity = (int)velocityTracker.getXVelocity();

				int initialYVelocity = (int)velocityTracker.getYVelocity();

				if ((Math.abs(initialXVelocity) + Math.abs(initialYVelocity) > mMinimumVelocity) &&

				    getChildCount() > 0)

				{

					fling(-initialXVelocity, -initialYVelocity);

				}

				if (mVelocityTracker != null)

				{

					mVelocityTracker.recycle();

					mVelocityTracker = null;

				}

		}

		return true;

	}

	/**

	 * Finds the next focusable component that fits in this View's bounds

	 * (excluding fading edges) pretending that this View's top is located at

	 * the parameter top.

	 *

	 * @param topFocus           look for a candidate is the one at the top of the bounds

	 *                           if topFocus is true, or at the bottom of the bounds if topFocus is

	 *                           false

	 * @param top                the top offset of the bounds in which a focusable must be

	 *                           found (the fading edge is assumed to start at this position)

	 * @param preferredFocusable the View that has highest priority and will be

	 *                           returned if it is within my bounds (null is valid)

	 * @return the next focusable component in the bounds or null if none can be

	 * found

	 */

	private View findFocusableViewInMyBounds(final boolean topFocus, final int top,

	                                         final boolean leftFocus, final int left,

	                                         View preferredFocusable)

	{

		/*

		 * The fading edge's transparent side should be considered for focus

		 * since it's mostly visible, so we divide the actual fading edge length

		 * by 2.

		 */

		final int verticalFadingEdgeLength = getVerticalFadingEdgeLength() / 2;

		final int topWithoutFadingEdge = top + verticalFadingEdgeLength;

		final int bottomWithoutFadingEdge = top + getHeight() - verticalFadingEdgeLength;

		final int horizontalFadingEdgeLength = getHorizontalFadingEdgeLength() / 2;

		final int leftWithoutFadingEdge = left + horizontalFadingEdgeLength;

		final int rightWithoutFadingEdge = left + getWidth() - horizontalFadingEdgeLength;

		if ((preferredFocusable != null) &&

		    (preferredFocusable.getTop() < bottomWithoutFadingEdge) &&

		    (preferredFocusable.getBottom() > topWithoutFadingEdge) &&

		    (preferredFocusable.getLeft() < rightWithoutFadingEdge) &&

		    (preferredFocusable.getRight() > leftWithoutFadingEdge))

		{

			return preferredFocusable;

		}

		return findFocusableViewInBounds(topFocus, topWithoutFadingEdge, bottomWithoutFadingEdge,

		                                 leftFocus, leftWithoutFadingEdge, rightWithoutFadingEdge);

	}

	/**

	 * Finds the next focusable component that fits in the specified bounds.

	 * 

	 *

	 * @param topFocus look for a candidate is the one at the top of the bounds

	 *                 if topFocus is true, or at the bottom of the bounds if topFocus is

	 *                 false

	 * @param top      the top offset of the bounds in which a focusable must be

	 *                 found

	 * @param bottom   the bottom offset of the bounds in which a focusable must

	 *                 be found

	 * @return the next focusable component in the bounds or null if none can

	 * be found

	 */

	private View findFocusableViewInBounds(boolean topFocus, int top, int bottom, boolean leftFocus,

	                                       int left, int right)

	{

		List<View> focusables = getFocusables(View.FOCUS_FORWARD);

		View focusCandidate = null;

		/*

		 * A fully contained focusable is one where its top is below the bound's

		 * top, and its bottom is above the bound's bottom. A partially

		 * contained focusable is one where some part of it is within the

		 * bounds, but it also has some part that is not within bounds.  A fully contained

		 * focusable is preferred to a partially contained focusable.

		 */

		boolean foundFullyContainedFocusable = false;

		int count = focusables.size();

		for (int i = 0; i < count; i++)

		{

			View view = focusables.get(i);

			int viewTop = view.getTop();

			int viewBottom = view.getBottom();

			int viewLeft = view.getLeft();

			int viewRight = view.getRight();

			if (top < viewBottom && viewTop < bottom && left < viewRight && viewLeft < right)

			{

				/*

				 * the focusable is in the target area, it is a candidate for

				 * focusing

				 */

				final boolean viewIsFullyContained = (top < viewTop) && (viewBottom < bottom) &&

				                                     (left < viewLeft) && (viewRight < right);

				if (focusCandidate == null)

				{

					/* No candidate, take this one */

					focusCandidate = view;

					foundFullyContainedFocusable = viewIsFullyContained;

				}

				else

				{

					final boolean viewIsCloserToVerticalBoundary =

					    (topFocus && viewTop < focusCandidate.getTop()) ||

					    (!topFocus && viewBottom > focusCandidate.getBottom());

					final boolean viewIsCloserToHorizontalBoundary =

					    (leftFocus && viewLeft < focusCandidate.getLeft()) ||

					    (!leftFocus && viewRight > focusCandidate.getRight());

					if (foundFullyContainedFocusable)

					{

						if (viewIsFullyContained && viewIsCloserToVerticalBoundary &&

						    viewIsCloserToHorizontalBoundary)

						{

							/*

							 * We're dealing with only fully contained views, so

							 * it has to be closer to the boundary to beat our

							 * candidate

							 */

							focusCandidate = view;

						}

					}

					else

					{

						if (viewIsFullyContained)

						{

							/* Any fully contained view beats a partially contained view */

							focusCandidate = view;

							foundFullyContainedFocusable = true;

						}

						else if (viewIsCloserToVerticalBoundary && viewIsCloserToHorizontalBoundary)

						{

							/*

							 * Partially contained view beats another partially

							 * contained view if it's closer

							 */

							focusCandidate = view;

						}

					}

				}

			}

		}

		return focusCandidate;

	}

	/**

	 * 
Handles scrolling in response to a "home/end" shortcut press. This

	 * method will scroll the view to the top or bottom and give the focus

	 * to the topmost/bottommost component in the new visible area. If no

	 * component is a good candidate for focus, this scrollview reclaims the

	 * focus.

	 *

	 * @param direction the scroll direction: {@link android.view.View#FOCUS_UP}

	 *                  to go the top of the view or

	 *                  {@link android.view.View#FOCUS_DOWN} to go the bottom

	 * @return true if the key event is consumed by this method, false otherwise

	 */

	public boolean fullScroll(int direction, boolean horizontal)

	{

		if (!horizontal)

		{

			boolean down = direction == View.FOCUS_DOWN;

			int height = getHeight();

			mTempRect.top = 0;

			mTempRect.bottom = height;

			if (down)

			{

				int count = getChildCount();

				if (count > 0)

				{

					View view = getChildAt(count - 1);

					mTempRect.bottom = view.getBottom();

					mTempRect.top = mTempRect.bottom - height;

				}

			}

			return scrollAndFocus(direction, mTempRect.top, mTempRect.bottom, 0, 0, 0);

		}

		else

		{

			boolean right = direction == View.FOCUS_DOWN;

			int width = getWidth();

			mTempRect.left = 0;

			mTempRect.right = width;

			if (right)

			{

				int count = getChildCount();

				if (count > 0)

				{

					View view = getChildAt(count - 1);

					mTempRect.right = view.getBottom();

					mTempRect.left = mTempRect.right - width;

				}

			}

			return scrollAndFocus(0, 0, 0, direction, mTempRect.top, mTempRect.bottom);

		}

	}

	/**

	 * 
Scrolls the view to make the area defined by top and

	 * bottom visible. This method attempts to give the focus

	 * to a component visible in this area. If no component can be focused in

	 * the new visible area, the focus is reclaimed by this scrollview.

	 *

	 * @param direction the scroll direction: {@link android.view.View#FOCUS_UP}

	 *                  to go upward

	 *                  {@link android.view.View#FOCUS_DOWN} to downward

	 * @param top       the top offset of the new area to be made visible

	 * @param bottom    the bottom offset of the new area to be made visible

	 * @return true if the key event is consumed by this method, false otherwise

	 */

	private boolean scrollAndFocus(int directionY, int top, int bottom, int directionX, int left,

	                               int right)

	{

		boolean handled = true;

		int height = getHeight();

		int containerTop = getScrollY();

		int containerBottom = containerTop + height;

		boolean up = directionY == View.FOCUS_UP;

		int width = getWidth();

		int containerLeft = getScrollX();

		int containerRight = containerLeft + width;

		boolean leftwards = directionX == View.FOCUS_UP;

		View newFocused = findFocusableViewInBounds(up, top, bottom, leftwards, left, right);

		if (newFocused == null)

		{

			newFocused = this;

		}

		if ((top >= containerTop && bottom <= containerBottom) ||

		    (left >= containerLeft && right <= containerRight))

		{

			handled = false;

		}

		else

		{

			int deltaY = up ? (top - containerTop) : (bottom - containerBottom);

			int deltaX = leftwards ? (left - containerLeft) : (right - containerRight);

			doScroll(deltaX, deltaY);

		}

		if (newFocused != findFocus() && newFocused.requestFocus(directionY))

		{

			mTwoDScrollViewMovedFocus = true;

			mTwoDScrollViewMovedFocus = false;

		}

		return handled;

	}

	/**

	 * Handle scrolling in response to an up or down arrow click.

	 *

	 * @param direction The direction corresponding to the arrow key that was

	 *                  pressed

	 * @return True if we consumed the event, false otherwise

	 */

	public boolean arrowScroll(int direction, boolean horizontal)

	{

		View currentFocused = findFocus();

		if (currentFocused == this)

			currentFocused = null;

		View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);

		final int maxJump =

		    horizontal ? getMaxScrollAmountHorizontal() : getMaxScrollAmountVertical();

		if (!horizontal)

		{

			if (nextFocused != null)

			{

				nextFocused.getDrawingRect(mTempRect);

				offsetDescendantRectToMyCoords(nextFocused, mTempRect);

				int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);

				doScroll(0, scrollDelta);

				nextFocused.requestFocus(direction);

			}

			else

			{

				// no new focus

				int scrollDelta = maxJump;

				if (direction == View.FOCUS_UP && getScrollY() < scrollDelta)

				{

					scrollDelta = getScrollY();

				}

				else if (direction == View.FOCUS_DOWN)

				{

					if (getChildCount() > 0)

					{

						int daBottom = getChildAt(0).getBottom();

						int screenBottom = getScrollY() + getHeight();

						if (daBottom - screenBottom < maxJump)

						{

							scrollDelta = daBottom - screenBottom;

						}

					}

				}

				if (scrollDelta == 0)

				{

					return false;

				}

				doScroll(0, direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta);

			}

		}

		else

		{

			if (nextFocused != null)

			{

				nextFocused.getDrawingRect(mTempRect);

				offsetDescendantRectToMyCoords(nextFocused, mTempRect);

				int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);

				doScroll(scrollDelta, 0);

				nextFocused.requestFocus(direction);

			}

			else

			{

				// no new focus

				int scrollDelta = maxJump;

				if (direction == View.FOCUS_UP && getScrollY() < scrollDelta)

				{

					scrollDelta = getScrollY();

				}

				else if (direction == View.FOCUS_DOWN)

				{

					if (getChildCount() > 0)

					{

						int daBottom = getChildAt(0).getBottom();

						int screenBottom = getScrollY() + getHeight();

						if (daBottom - screenBottom < maxJump)

						{

							scrollDelta = daBottom - screenBottom;

						}

					}

				}

				if (scrollDelta == 0)

				{

					return false;

				}

				doScroll(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta, 0);

			}

		}

		return true;

	}

	/**

	 * Smooth scroll by a Y delta

	 *

	 * @param delta the number of pixels to scroll by on the Y axis

	 */

	private void doScroll(int deltaX, int deltaY)