Implement pseudo 3d overscroll for tab switcher
Bug: 5255100
Change-Id: Id756e36bba2644cc1be1a699f80dbd78119ec56f
diff --git a/res/layout-land/nav_screen.xml b/res/layout-land/nav_screen.xml
index 885bfd1..ba7ac26 100644
--- a/res/layout-land/nav_screen.xml
+++ b/res/layout-land/nav_screen.xml
@@ -20,12 +20,16 @@
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/browser_background_holo" >
+ <com.android.browser.NavTabScroller
+ android:id="@+id/scroller"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent" />
<LinearLayout
android:id="@+id/tabbar"
android:orientation="horizontal"
android:layout_width="match_parent"
- android:layout_height="44dip"
- android:layout_alignParentBottom="true"
+ android:layout_height="@dimen/toolbar_height"
+ android:layout_gravity="top"
android:gravity="right"
android:background="#C0404040">
<ImageButton
@@ -54,9 +58,4 @@
android:contentDescription="@string/accessibility_button_more"
android:src="@drawable/ic_menu_overflow" />
</LinearLayout>
- <com.android.browser.NavTabGallery
- android:id="@+id/scroller"
- android:layout_width="match_parent"
- android:layout_height="match_parent"
- android:layout_above="@id/tabbar" />
</RelativeLayout>
diff --git a/res/layout/anim_screen.xml b/res/layout/anim_screen.xml
index 399595e..0cdc931 100644
--- a/res/layout/anim_screen.xml
+++ b/res/layout/anim_screen.xml
@@ -20,13 +20,15 @@
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
- android:focusable="false">
+ android:focusable="false"
+ android:background="@drawable/browser_background_holo">
<ImageView
android:id="@+id/title"
android:layout_width="match_parent"
android:layout_height="@dimen/toolbar_height" />
<ImageView
android:id="@+id/content"
- android:layout_width="match_parent"
- android:layout_height="match_parent" />
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:background="@color/white" />
</LinearLayout>
diff --git a/res/layout/nav_screen.xml b/res/layout/nav_screen.xml
index 0ea332f..ae0db1b 100644
--- a/res/layout/nav_screen.xml
+++ b/res/layout/nav_screen.xml
@@ -20,7 +20,7 @@
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/browser_background_holo">
- <com.android.browser.NavTabGallery
+ <com.android.browser.NavTabScroller
android:id="@+id/scroller"
android:layout_width="match_parent"
android:layout_height="match_parent"
diff --git a/src/com/android/browser/NavScreen.java b/src/com/android/browser/NavScreen.java
index 768f9ba..1626183 100644
--- a/src/com/android/browser/NavScreen.java
+++ b/src/com/android/browser/NavScreen.java
@@ -37,9 +37,9 @@
import android.widget.RelativeLayout;
import android.widget.TextView;
-import com.android.browser.NavTabGallery.OnRemoveListener;
+import com.android.browser.NavTabScroller.OnLayoutListener;
+import com.android.browser.NavTabScroller.OnRemoveListener;
import com.android.browser.TabControl.OnThumbnailUpdatedListener;
-import com.android.browser.view.Gallery.OnScrollFinishedListener;
import java.util.HashMap;
@@ -47,9 +47,6 @@
implements OnClickListener, OnMenuItemClickListener, OnThumbnailUpdatedListener {
- private static final int SCROLL_MIN = 200;
- private static final int SCROLL_FACTOR = 20;
-
UiController mUiController;
PhoneUi mUi;
Tab mTab;
@@ -66,7 +63,7 @@
ImageView mFavicon;
ImageButton mCloseTab;
- NavTabGallery mScroller;
+ NavTabScroller mScroller;
TabAdapter mAdapter;
int mOrientation;
boolean mNeedsMenu;
@@ -81,22 +78,18 @@
init();
}
- protected Tab getSelectedTab() {
- return (Tab) mScroller.getSelectedItem();
- }
-
protected void showMenu() {
PopupMenu popup = new PopupMenu(mContext, mMore);
Menu menu = popup.getMenu();
popup.getMenuInflater().inflate(R.menu.browser, menu);
- mUiController.updateMenuState(mScroller.getSelectedItem(), menu);
+ mUiController.updateMenuState(mUiController.getCurrentTab(), menu);
popup.setOnMenuItemClickListener(this);
popup.show();
}
@Override
public boolean onMenuItemClick(MenuItem item) {
- mUi.hideNavScreen(false);
+ mUi.hideNavScreen(mUiController.getTabControl().getCurrentPosition(), false);
return mUiController.onOptionsItemSelected(item);
}
@@ -104,15 +97,14 @@
return mActivity.getResources().getDimension(R.dimen.toolbar_height);
}
- // for configuration changes
@Override
protected void onConfigurationChanged(Configuration newconfig) {
if (newconfig.orientation != mOrientation) {
- int selIx = mScroller.getSelectionIndex();
+ int sv = mScroller.getScrollValue();
removeAllViews();
mOrientation = newconfig.orientation;
init();
- mScroller.setSelection(selIx);
+ mScroller.setScrollValue(sv);
mAdapter.notifyDataSetChanged();
}
}
@@ -127,7 +119,7 @@
mBookmarks.setOnClickListener(this);
mNewTab.setOnClickListener(this);
mMore.setOnClickListener(this);
- mScroller = (NavTabGallery) findViewById(R.id.scroller);
+ mScroller = (NavTabScroller) findViewById(R.id.scroller);
TabControl tc = mUiController.getTabControl();
mTabViews = new HashMap<Tab, View>(tc.getTabCount());
mAdapter = new TabAdapter(mContext, tc);
@@ -150,28 +142,12 @@
@Override
public void onClick(View v) {
- WebView web = (mTab != null) ? mTab.getWebView() : null;
- if (web != null) {
- if (mForward == v) {
- mUi.hideNavScreen(true);
- mTab.goForward();
- } else if (mRefresh == v) {
- mUi.hideNavScreen(true);
- web.reload();
- }
- }
if (mBookmarks == v) {
- switchToSelected();
mUiController.bookmarksOrHistoryPicker(false);
} else if (mNewTab == v) {
openNewTab();
} else if (mMore == v) {
showMenu();
- } else if (mTitle == v) {
- mUi.getTitleBar().setSkipTitleBarAnimations(true);
- close(false);
- mUi.editUrl(false);
- mUi.getTitleBar().setSkipTitleBarAnimations(false);
}
}
@@ -182,49 +158,46 @@
} else {
mUiController.closeTab(tab);
}
- mAdapter.notifyDataSetChanged();
+ mScroller.handleDataChanged();
}
}
private void openNewTab() {
// need to call openTab explicitely with setactive false
- Tab tab = mUiController.openTab(BrowserSettings.getInstance().getHomePage(),
+ final Tab tab = mUiController.openTab(BrowserSettings.getInstance().getHomePage(),
false, false, false);
- int duration = 0;
if (tab != null) {
mUiController.setBlockEvents(true);
- int oldsel = mScroller.getSelectedItemPosition();
final int tix = mUi.mTabControl.getTabPosition(tab);
- duration = SCROLL_MIN + SCROLL_FACTOR * Math.abs(oldsel - tix);
- mScroller.handleDataChanged();
- mScroller.smoothScrollToPosition(tix, duration, new OnScrollFinishedListener() {
+ mScroller.setOnLayoutListener(new OnLayoutListener() {
+
@Override
- public void onScrollFinished() {
- mUiController.setBlockEvents(false);
- mUi.hideNavScreen(true);
- switchToSelected();
+ public void onLayout(int l, int t, int r, int b) {
+ mUi.hideNavScreen(tix, true);
+ switchToTab(tab);
}
});
+ mScroller.handleDataChanged(tix);
+ mUiController.setBlockEvents(false);
}
}
- View getSelectedTabView() {
- return mScroller.getSelectedTab();
- }
-
- private void switchToSelected() {
- Tab tab = (Tab) mScroller.getSelectedItem();
+ private void switchToTab(Tab tab) {
if (tab != mUi.getActiveTab()) {
mUiController.setActiveTab(tab);
}
}
- protected void close() {
- close(true);
+ protected void close(int position) {
+ close(position, true);
}
- protected void close(boolean animate) {
- mUi.hideNavScreen(animate);
+ protected void close(int position, boolean animate) {
+ mUi.hideNavScreen(position, animate);
+ }
+
+ protected NavTabView getTabView(int pos) {
+ return mScroller.getTabView(pos);
}
class TabAdapter extends BaseAdapter {
@@ -263,15 +236,13 @@
if (tabview.isClose(v)) {
mScroller.animateOut(tabview);
} else if (tabview.isTitle(v)) {
- mScroller.setSelection(position);
- switchToSelected();
+ switchToTab(tab);
mUi.getTitleBar().setSkipTitleBarAnimations(true);
- close(false);
+ close(position, false);
mUi.editUrl(false);
mUi.getTitleBar().setSkipTitleBarAnimations(false);
} else if (tabview.isWebView(v)) {
- mScroller.setSelection(position);
- close();
+ close(position);
}
}
});
@@ -285,7 +256,6 @@
View v = mTabViews.get(t);
if (v != null) {
v.invalidate();
- mScroller.invalidate();
}
}
diff --git a/src/com/android/browser/NavTabGallery.java b/src/com/android/browser/NavTabGallery.java
deleted file mode 100644
index af02e8d..0000000
--- a/src/com/android/browser/NavTabGallery.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright (C) 2011 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 com.android.browser;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
-import android.content.Context;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.view.View;
-
-import com.android.browser.view.Gallery;
-
-/**
- * custom view for displaying tabs in the nav screen
- */
-public class NavTabGallery extends Gallery {
-
- interface OnRemoveListener {
- public void onRemovePosition(int position);
- }
-
- // after drag animation velocity in pixels/sec
- private static final float MIN_VELOCITY = 1500;
-
- private OnRemoveListener mRemoveListener;
- private boolean mBlockUpCallback;
- private Animator mAnimator;
-
- public NavTabGallery(Context context, AttributeSet attrs, int defStyle) {
- super(context, attrs, defStyle);
- }
-
- public NavTabGallery(Context context, AttributeSet attrs) {
- super(context, attrs);
- }
-
- public NavTabGallery(Context context) {
- super(context);
- }
-
- public void setOnRemoveListener(OnRemoveListener l) {
- mRemoveListener = l;
- }
-
- protected void setSelection(int ix) {
- super.setSelectedPositionInt(ix);
- }
-
- protected int getSelectionIndex() {
- return getSelectedItemPosition();
- }
-
- protected Tab getSelectedItem() {
- return (Tab) mAdapter.getItem(getSelectedItemPosition());
- }
-
- View getSelectedTab() {
- return getSelectedView();
- }
-
- @Override
- protected void onOrthoDrag(View v, MotionEvent down, MotionEvent move,
- float distance) {
- if (mAnimator == null) {
- offsetView(v, - distance);
- }
- }
-
- @Override
- protected void onOrthoFling(View v, MotionEvent down, MotionEvent move,
- float velocity) {
- if ((mAnimator == null) && (Math.abs(velocity) > MIN_VELOCITY)) {
- mBlockUpCallback = true;
- animateOut(v, velocity);
- }
- }
-
- @Override
- protected void onUp(View downView) {
- if (mAnimator != null) return;
- if (mBlockUpCallback) {
- mBlockUpCallback = false;
- return;
- }
- if (mIsOrthoDragged && downView != null) {
- // offset
- int diff = calculateTop(downView, false) - (mHorizontal ? downView.getTop()
- : downView.getLeft());
- if (Math.abs(diff) > (mHorizontal ? downView.getHeight() : downView.getWidth()) / 2) {
- // remove it
- animateOut(downView, - Math.signum(diff) * MIN_VELOCITY);
- } else {
- // snap back
- offsetView(downView, diff);
- }
- } else {
- super.onUp(downView);
- }
- }
-
- private void offsetView(View v, float distance) {
- if (mHorizontal) {
- v.offsetTopAndBottom((int) distance);
- } else {
- v.offsetLeftAndRight((int) distance);
- }
- }
-
- protected void animateOut(View v) {
- animateOut(v, -MIN_VELOCITY);
- }
-
- private void animateOut(final View v, float velocity) {
- if ((v == null) || (mAnimator != null)) return;
- final int position = mFirstPosition + indexOfChild(v);
- int target = 0;
- if (velocity < 0) {
- target = mHorizontal ? -v.getHeight() : - v.getWidth();
- } else {
- target = mHorizontal ? getHeight() : getWidth();
- }
- int distance = target - (mHorizontal ? v.getTop() : v.getLeft());
- long duration = (long) (Math.abs(distance) * 1000 / Math.abs(velocity));
- if (mHorizontal) {
- mAnimator = ObjectAnimator.ofFloat(v, TRANSLATION_Y, 0, target);
- } else {
- mAnimator = ObjectAnimator.ofFloat(v, TRANSLATION_X, 0, target);
- }
- mAnimator.setDuration(duration);
- mAnimator.addListener(new AnimatorListenerAdapter() {
- public void onAnimationEnd(Animator a) {
- if (mRemoveListener != null) {
- boolean needsGap = position < (mAdapter.getCount() - 1);
- if (needsGap) {
- setGapPosition(position, mHorizontal ? v.getWidth() : v.getHeight());
- }
- mRemoveListener.onRemovePosition(position);
- if (!needsGap && (position > 0) && (mAdapter.getCount() > 0)) {
- scrollToChild(position - 1);
- }
- mAnimator = null;
- }
- }
- });
- mAnimator.start();
- }
-
-}
diff --git a/src/com/android/browser/NavTabScroller.java b/src/com/android/browser/NavTabScroller.java
new file mode 100644
index 0000000..03bf595
--- /dev/null
+++ b/src/com/android/browser/NavTabScroller.java
@@ -0,0 +1,516 @@
+/*
+ * Copyright (C) 2011 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 com.android.browser;
+
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.database.DataSetObserver;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.DecelerateInterpolator;
+import android.widget.BaseAdapter;
+import android.widget.LinearLayout;
+
+import com.android.browser.view.ScrollerView;
+
+/**
+ * custom view for displaying tabs in the nav screen
+ */
+public class NavTabScroller extends ScrollerView {
+
+ static final int INVALID_POSITION = -1;
+ static final float[] PULL_FACTOR = { 2.5f, 0.9f };
+
+ interface OnRemoveListener {
+ public void onRemovePosition(int position);
+ }
+
+ interface OnLayoutListener {
+ public void onLayout(int l, int t, int r, int b);
+ }
+
+ private ContentLayout mContentView;
+ private BaseAdapter mAdapter;
+ private OnRemoveListener mRemoveListener;
+ private OnLayoutListener mLayoutListener;
+ private int mGap;
+ private int mGapPosition;
+ private ObjectAnimator mGapAnimator;
+
+ // after drag animation velocity in pixels/sec
+ private static final float MIN_VELOCITY = 1500;
+ private Animator mAnimator;
+
+ private float mFlingVelocity;
+ private boolean mNeedsScroll;
+ private int mScrollPosition;
+
+ DecelerateInterpolator mCubic;
+ int mPullValue;
+
+ public NavTabScroller(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ init(context);
+ }
+
+ public NavTabScroller(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init(context);
+ }
+
+ public NavTabScroller(Context context) {
+ super(context);
+ init(context);
+ }
+
+ private void init(Context ctx) {
+ mCubic = new DecelerateInterpolator(1.5f);
+ mGapPosition = INVALID_POSITION;
+ setHorizontalScrollBarEnabled(false);
+ setVerticalScrollBarEnabled(false);
+ mContentView = new ContentLayout(ctx, this);
+ mContentView.setOrientation(LinearLayout.HORIZONTAL);
+ addView(mContentView);
+ mContentView.setLayoutParams(
+ new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT));
+ // ProGuard !
+ setGap(getGap());
+ mFlingVelocity = getContext().getResources().getDisplayMetrics().density
+ * MIN_VELOCITY;
+ }
+
+ protected int getScrollValue() {
+ return mHorizontal ? mScrollX : mScrollY;
+ }
+
+ protected void setScrollValue(int value) {
+ scrollTo(mHorizontal ? value : 0, mHorizontal ? 0 : value);
+ }
+
+ protected NavTabView getTabView(int pos) {
+ return (NavTabView) mContentView.getChildAt(pos);
+ }
+
+ /**
+ * define a visual gap in the list of items
+ * the gap is rendered in front (left or above)
+ * the given position
+ * @param position
+ * @param gap
+ */
+ public void setGapPosition(int position, int gap) {
+ mGapPosition = position;
+ mGap = gap;
+ }
+
+ public void setGap(int gap) {
+ if (mGapPosition != INVALID_POSITION) {
+ mGap = gap;
+ postInvalidate();
+ }
+ }
+
+ public int getGap() {
+ return mGap;
+ }
+
+ protected boolean isHorizontal() {
+ return mHorizontal;
+ }
+
+ public void setOrientation(int orientation) {
+ mContentView.setOrientation(orientation);
+ if (orientation == LinearLayout.HORIZONTAL) {
+ mContentView.setLayoutParams(
+ new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT));
+ } else {
+ mContentView.setLayoutParams(
+ new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
+ }
+ super.setOrientation(orientation);
+ }
+
+ @Override
+ protected void onMeasure(int wspec, int hspec) {
+ super.onMeasure(wspec, hspec);
+ calcPadding();
+ }
+
+ private void calcPadding() {
+ if (mAdapter.getCount() > 0) {
+ View v = mContentView.getChildAt(0);
+ if (mHorizontal) {
+ int pad = (getMeasuredWidth() - v.getMeasuredWidth()) / 2 + 2;
+ mContentView.setPadding(pad, 0, pad, 0);
+ } else {
+ int pad = (getMeasuredHeight() - v.getMeasuredHeight()) / 2 + 2;
+ mContentView.setPadding(0, pad, 0, pad);
+ }
+ }
+ }
+
+ public void setAdapter(BaseAdapter adapter) {
+ setAdapter(adapter, 0);
+ }
+
+
+ public void setOnRemoveListener(OnRemoveListener l) {
+ mRemoveListener = l;
+ }
+
+ public void setOnLayoutListener(OnLayoutListener l) {
+ mLayoutListener = l;
+ }
+
+ protected void setAdapter(BaseAdapter adapter, int selection) {
+ mAdapter = adapter;
+ mAdapter.registerDataSetObserver(new DataSetObserver() {
+
+ @Override
+ public void onChanged() {
+ super.onChanged();
+ handleDataChanged();
+ }
+
+ @Override
+ public void onInvalidated() {
+ super.onInvalidated();
+ }
+ });
+ handleDataChanged(selection);
+ }
+
+ protected ViewGroup getContentView() {
+ return mContentView;
+ }
+
+ protected int getRelativeChildTop(int ix) {
+ return mContentView.getChildAt(ix).getTop() - mScrollY;
+ }
+
+ protected void handleDataChanged() {
+ handleDataChanged(INVALID_POSITION);
+ }
+
+ protected void handleDataChanged(int newscroll) {
+ int scroll = getScrollValue();
+ if (mGapAnimator != null) {
+ mGapAnimator.cancel();
+ }
+ mContentView.removeAllViews();
+ for (int i = 0; i < mAdapter.getCount(); i++) {
+ View v = mAdapter.getView(i, null, mContentView);
+ LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
+ LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+ lp.gravity = (mHorizontal ? Gravity.CENTER_VERTICAL : Gravity.CENTER_HORIZONTAL);
+ mContentView.addView(v, lp);
+ if ((mGapPosition > INVALID_POSITION) && (i >= mGapPosition)) {
+ adjustViewGap(v, mGap);
+ }
+ }
+ if (newscroll > INVALID_POSITION) {
+ newscroll = Math.min(mAdapter.getCount() - 1, newscroll);
+ mNeedsScroll = true;
+ mScrollPosition = newscroll;
+ requestLayout();
+ } else {
+ setScrollValue(scroll);
+ }
+ if (mGapPosition > INVALID_POSITION) {
+ mGapAnimator = ObjectAnimator.ofInt(this, "gap", mGap, 0);
+ mGapAnimator.setDuration(250);
+ mGapAnimator.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator a) {
+ mGap = 0;
+ adjustGap();
+ mGapPosition = INVALID_POSITION;
+ mGapAnimator = null;
+ mContentView.requestLayout();
+ }
+ });
+ mGapAnimator.start();
+ }
+
+ }
+
+ protected void finishScroller() {
+ mScroller.forceFinished(true);
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int l, int t, int r, int b) {
+ super.onLayout(changed, l, t, r, b);
+ if (mNeedsScroll) {
+ mScroller.forceFinished(true);
+ snapToSelected(mScrollPosition, false);
+ mNeedsScroll = false;
+ }
+ if (mLayoutListener != null) {
+ mLayoutListener.onLayout(l, t, r, b);
+ mLayoutListener = null;
+ }
+ }
+
+ void adjustGap() {
+ for (int i = 0; i < mContentView.getChildCount(); i++) {
+ if (i >= mGapPosition) {
+ final View child = mContentView.getChildAt(i);
+ adjustViewGap(child, mGap);
+ }
+ }
+ }
+
+ private void adjustViewGap(View view, int gap) {
+ if (mHorizontal) {
+ view.setTranslationX(gap);
+ } else {
+ view.setTranslationY(gap);
+ }
+ }
+
+
+ void clearTabs() {
+ mContentView.removeAllViews();
+ }
+
+ void snapToSelected(int pos, boolean smooth) {
+ if (pos < 0) return;
+ View v = mContentView.getChildAt(pos);
+ int sx = 0;
+ int sy = 0;
+ if (mHorizontal) {
+ sx = (v.getLeft() + v.getRight() - getWidth()) / 2;
+ } else {
+ sy = (v.getTop() + v.getBottom() - getHeight()) / 2;
+ }
+ if ((sx != mScrollX) || (sy != mScrollY)) {
+ if (smooth) {
+ smoothScrollTo(sx,sy);
+ } else {
+ scrollTo(sx, sy);
+ }
+ }
+ }
+
+ protected void animateOut(View v) {
+ if (v == null) return;
+ animateOut(v, -mFlingVelocity);
+ }
+
+ private void animateOut(final View v, float velocity) {
+ float start = mHorizontal ? v.getTranslationY() : v.getTranslationX();
+ animateOut(v, velocity, start);
+ }
+
+ private void animateOut(final View v, float velocity, float start) {
+ if ((v == null) || (mAnimator != null)) return;
+ final int position = mContentView.indexOfChild(v);
+ int target = 0;
+ if (velocity < 0) {
+ target = mHorizontal ? -getHeight() : -getWidth();
+ } else {
+ target = mHorizontal ? getHeight() : getWidth();
+ }
+ int distance = target - (mHorizontal ? v.getTop() : v.getLeft());
+ long duration = (long) (Math.abs(distance) * 1000 / Math.abs(velocity));
+ if (mHorizontal) {
+ mAnimator = ObjectAnimator.ofFloat(v, TRANSLATION_Y, start, target);
+ } else {
+ mAnimator = ObjectAnimator.ofFloat(v, TRANSLATION_X, start, target);
+ }
+ mAnimator.setDuration(duration);
+ mAnimator.addListener(new AnimatorListenerAdapter() {
+ public void onAnimationEnd(Animator a) {
+ if (mRemoveListener != null) {
+ boolean needsGap = position < (mAdapter.getCount() - 1);
+ if (needsGap) {
+ setGapPosition(position, mHorizontal ? v.getWidth() : v.getHeight());
+ }
+ mRemoveListener.onRemovePosition(position);
+ mAnimator = null;
+ }
+ }
+ });
+ mAnimator.start();
+ }
+
+ @Override
+ public void draw(Canvas canvas) {
+ super.draw(canvas);
+ if (mGapPosition > INVALID_POSITION) {
+ adjustGap();
+ }
+ }
+
+ @Override
+ protected View findViewAt(int x, int y) {
+ x += mScrollX;
+ y += mScrollY;
+ final int count = mContentView.getChildCount();
+ for (int i = count - 1; i >= 0; i--) {
+ View child = mContentView.getChildAt(i);
+ if (child.getVisibility() == View.VISIBLE) {
+ if ((x >= child.getLeft()) && (x < child.getRight())
+ && (y >= child.getTop()) && (y < child.getBottom())) {
+ return child;
+ }
+ }
+ }
+ return null;
+ }
+
+ @Override
+ protected void onOrthoDrag(View v, float distance) {
+ if ((v != null) && (mAnimator == null)) {
+ offsetView(v, distance);
+ }
+ }
+
+ @Override
+ protected void onOrthoDragFinished(View downView) {
+ if (mAnimator != null) return;
+ if (mIsOrthoDragged && downView != null) {
+ // offset
+ float diff = mHorizontal ? downView.getTranslationY() : downView.getTranslationX();
+ if (Math.abs(diff) > (mHorizontal ? downView.getHeight() : downView.getWidth()) / 2) {
+ // remove it
+ animateOut(downView, Math.signum(diff) * mFlingVelocity, diff);
+ } else {
+ // snap back
+ offsetView(downView, 0);
+ }
+ }
+ }
+
+ @Override
+ protected void onOrthoFling(View v, float velocity) {
+ if (v == null) return;
+ if (mAnimator == null && Math.abs(velocity) > mFlingVelocity / 2) {
+ animateOut(v, velocity);
+ } else {
+ offsetView(v, 0);
+ }
+ }
+
+ private void offsetView(View v, float distance) {
+ if (mHorizontal) {
+ v.setTranslationY(distance);
+ } else {
+ v.setTranslationX(distance);
+ }
+ }
+
+ private float ease(DecelerateInterpolator inter, float value, float start, float dist, float duration) {
+ return start + dist * inter.getInterpolation(value / duration);
+ }
+
+ @Override
+ protected void onPull(int delta) {
+ boolean layer = false;
+ int count = 2;
+ if (delta == 0 && mPullValue == 0) return;
+ if (delta == 0 && mPullValue != 0) {
+ // reset
+ for (int i = 0; i < count; i++) {
+ View child = mContentView.getChildAt((mPullValue < 0)
+ ? i
+ : mContentView.getChildCount() - 1 - i);
+ if (child == null) break;
+ ObjectAnimator trans = ObjectAnimator.ofFloat(child,
+ mHorizontal ? "translationX" : "translationY",
+ mHorizontal ? getTranslationX() : getTranslationY(),
+ 0);
+ ObjectAnimator rot = ObjectAnimator.ofFloat(child,
+ mHorizontal ? "rotationY" : "rotationX",
+ mHorizontal ? getRotationY() : getRotationX(),
+ 0);
+ AnimatorSet set = new AnimatorSet();
+ set.playTogether(trans, rot);
+ set.setDuration(100);
+ set.start();
+ }
+ mPullValue = 0;
+ } else {
+ if (mPullValue == 0) {
+ layer = true;
+ }
+ mPullValue += delta;
+ }
+ final int height = mHorizontal ? getWidth() : getHeight();
+ int oscroll = Math.abs(mPullValue);
+ int factor = (mPullValue <= 0) ? 1 : -1;
+ for (int i = 0; i < count; i++) {
+ View child = mContentView.getChildAt((mPullValue < 0)
+ ? i
+ : mContentView.getChildCount() - 1 - i);
+ if (child == null) break;
+ if (layer) {
+ }
+ float k = PULL_FACTOR[i];
+ float rot = -factor * ease(mCubic, oscroll, 0, k * 2, height);
+ int y = factor * (int) ease(mCubic, oscroll, 0, k*20, height);
+ if (mHorizontal) {
+ child.setTranslationX(y);
+ } else {
+ child.setTranslationY(y);
+ }
+ if (mHorizontal) {
+ child.setRotationY(-rot);
+ } else {
+ child.setRotationX(rot);
+ }
+ }
+ }
+
+ static class ContentLayout extends LinearLayout {
+
+ NavTabScroller mScroller;
+
+ public ContentLayout(Context context, NavTabScroller scroller) {
+ super(context);
+ mScroller = scroller;
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+ if (mScroller.getGap() > 0) {
+ View v = getChildAt(0);
+ if (v != null) {
+ if (mScroller.isHorizontal()) {
+ int total = v.getMeasuredWidth() + getMeasuredWidth();
+ setMeasuredDimension(total, getMeasuredHeight());
+ } else {
+ int total = v.getMeasuredHeight() + getMeasuredHeight();
+ setMeasuredDimension(getMeasuredWidth(), total);
+ }
+ }
+
+ }
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/android/browser/PhoneUi.java b/src/com/android/browser/PhoneUi.java
index 61acef5..4772ff1 100644
--- a/src/com/android/browser/PhoneUi.java
+++ b/src/com/android/browser/PhoneUi.java
@@ -36,7 +36,6 @@
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
-import android.view.animation.DecelerateInterpolator;
import android.webkit.WebView;
import android.widget.FrameLayout;
import android.widget.ImageView;
@@ -90,7 +89,7 @@
@Override
public boolean onBackKey() {
if (mNavScreen != null) {
- mNavScreen.close();
+ mNavScreen.close(mUiController.getTabControl().getCurrentPosition());
return true;
}
return super.onBackKey();
@@ -191,7 +190,7 @@
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (mNavScreen != null) {
- hideNavScreen(false);
+ hideNavScreen(mUiController.getTabControl().getCurrentPosition(), false);
}
return false;
}
@@ -278,7 +277,7 @@
@Override
public void showWeb(boolean animate) {
super.showWeb(animate);
- hideNavScreen(animate);
+ hideNavScreen(mUiController.getTabControl().getCurrentPosition(), animate);
}
void showNavScreen() {
@@ -292,20 +291,20 @@
mCustomViewContainer.addView(animView, COVER_SCREEN_PARAMS);
mCustomViewContainer.setVisibility(View.VISIBLE);
mCustomViewContainer.bringToFront();
- View target = ((NavTabView) mNavScreen.mScroller.getSelectedView()).mImage;
int fromLeft = 0;
int fromTop = getTitleBar().getHeight();
int fromRight = mContentView.getWidth();
int fromBottom = mContentView.getHeight();
- int width = target.getWidth();
- int height = target.getHeight();
+ int width = mActivity.getResources().getDimensionPixelSize(R.dimen.nav_tab_width);
+ int height = mActivity.getResources().getDimensionPixelSize(R.dimen.nav_tab_height);
int toLeft = (mContentView.getWidth() - width) / 2;
- int toTop = fromTop + (mContentView.getHeight() - fromTop - height) / 2;
+ int toTop = ((fromBottom - (fromTop + height)) / 2 + fromTop);
int toRight = toLeft + width;
int toBottom = toTop + height;
float scaleFactor = width / (float) mContentView.getWidth();
detachTab(mActiveTab);
mContentView.setVisibility(View.GONE);
+ AnimatorSet set1 = new AnimatorSet();
AnimatorSet inanim = new AnimatorSet();
ObjectAnimator tx = ObjectAnimator.ofInt(ascreen.mContent, "left",
fromLeft, toLeft);
@@ -317,12 +316,14 @@
fromBottom, toBottom);
ObjectAnimator title = ObjectAnimator.ofFloat(ascreen.mTitle, "alpha",
1f, 0f);
- ObjectAnimator content = ObjectAnimator.ofFloat(ascreen.mContent, "alpha",
- 1f, 0f);
ObjectAnimator sx = ObjectAnimator.ofFloat(ascreen, "scaleFactor",
1f, scaleFactor);
- inanim.playTogether(tx, ty, tr, tb, title, content, sx);
- inanim.addListener(new AnimatorListenerAdapter() {
+ ObjectAnimator blend1 = ObjectAnimator.ofFloat(ascreen.mMain, "alpha", 1, 0);
+ blend1.setDuration(100);
+
+ inanim.playTogether(tx, ty, tr, tb, sx, title);
+ inanim.setDuration(200);
+ set1.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator anim) {
mCustomViewContainer.removeView(animView);
@@ -330,9 +331,8 @@
mUiController.setBlockEvents(false);
}
});
- inanim.setInterpolator(new DecelerateInterpolator(2f));
- inanim.setDuration(300);
- inanim.start();
+ set1.playSequentially(inanim, blend1);
+ set1.start();
}
private void finishAnimationIn() {
@@ -343,9 +343,9 @@
}
}
- void hideNavScreen(boolean animate) {
+ void hideNavScreen(int position, boolean animate) {
if (mNavScreen == null) return;
- final Tab tab = mNavScreen.getSelectedTab();
+ final Tab tab = mUiController.getTabControl().getTab(position);
if ((tab == null) || !animate) {
if (tab != null) {
setActiveTab(tab);
@@ -357,7 +357,7 @@
finishAnimateOut();
return;
}
- NavTabView tabview = (NavTabView) mNavScreen.getSelectedTabView();
+ NavTabView tabview = (NavTabView) mNavScreen.getTabView(position);
if (tabview == null) {
if (mTabControl.getTabCount() > 0) {
// use a fallback tab
@@ -371,23 +371,36 @@
mUiController.setActiveTab(tab);
mContentView.setVisibility(View.VISIBLE);
final AnimScreen screen = new AnimScreen(mActivity, tab.getScreenshot());
- View target = ((NavTabView) mNavScreen.mScroller.getSelectedView()).mImage;
+ mCustomViewContainer.addView(screen.mMain, COVER_SCREEN_PARAMS);
+ screen.mMain.layout(0, 0, mContentView.getWidth(),
+ mContentView.getHeight());
+ mNavScreen.mScroller.finishScroller();
+ ImageView target = tabview.mImage;
int toLeft = 0;
int toTop = getTitleBar().getHeight();
int toRight = mContentView.getWidth();
- int width = target.getWidth();
- int height = target.getHeight();
- int[] pos = new int[2];
- tabview.mImage.getLocationInWindow(pos);
- int fromLeft = pos[0];
- int fromTop = pos[1];
+ int width = target.getDrawable().getIntrinsicWidth();
+ int height = target.getDrawable().getIntrinsicHeight();
+ int fromLeft = tabview.getLeft() + target.getLeft() - mNavScreen.mScroller.getScrollX();
+ int fromTop = tabview.getTop() + target.getTop() - mNavScreen.mScroller.getScrollY();
int fromRight = fromLeft + width;
int fromBottom = fromTop + height;
float scaleFactor = mContentView.getWidth() / (float) width;
- int toBottom = (int) (height * scaleFactor);
- screen.mMain.setAlpha(0f);
- mCustomViewContainer.addView(screen.mMain, COVER_SCREEN_PARAMS);
- AnimatorSet animSet = new AnimatorSet();
+ int toBottom = toTop + (int) (height * scaleFactor);
+ ObjectAnimator l1 = ObjectAnimator.ofInt(screen.mContent, "left",
+ fromLeft, fromLeft);
+ ObjectAnimator t1 = ObjectAnimator.ofInt(screen.mContent, "top",
+ fromTop, fromTop);
+ ObjectAnimator r1 = ObjectAnimator.ofInt(screen.mContent, "right",
+ fromRight, fromRight);
+ ObjectAnimator b1 = ObjectAnimator.ofInt(screen.mContent, "bottom",
+ fromBottom, fromBottom);
+ AnimatorSet set1 = new AnimatorSet();
+ ObjectAnimator fade2 = ObjectAnimator.ofFloat(screen.mMain, "alpha", 0f, 1f);
+ ObjectAnimator fade1 = ObjectAnimator.ofFloat(mNavScreen, "alpha", 1f, 0f);
+ set1.playTogether(l1, t1, r1, b1, fade1, fade2);
+ set1.setDuration(100);
+ AnimatorSet set2 = new AnimatorSet();
ObjectAnimator l = ObjectAnimator.ofInt(screen.mContent, "left",
fromLeft, toLeft);
ObjectAnimator t = ObjectAnimator.ofInt(screen.mContent, "top",
@@ -398,11 +411,13 @@
fromBottom, toBottom);
ObjectAnimator scale = ObjectAnimator.ofFloat(screen, "scaleFactor",
1f, scaleFactor);
- ObjectAnimator alpha = ObjectAnimator.ofFloat(screen.mMain, "alpha", 1f, 1f);
ObjectAnimator otheralpha = ObjectAnimator.ofFloat(mCustomViewContainer, "alpha", 1f, 0f);
- alpha.setStartDelay(100);
- animSet.playTogether(l, t, r, b, scale, alpha, otheralpha);
- animSet.addListener(new AnimatorListenerAdapter() {
+ otheralpha.setDuration(100);
+ set2.playTogether(l, t, r, b, scale);
+ set2.setDuration(200);
+ AnimatorSet combo = new AnimatorSet();
+ combo.playSequentially(set1, set2, otheralpha);
+ combo.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator anim) {
mCustomViewContainer.removeView(screen.mMain);
@@ -410,8 +425,7 @@
mUiController.setBlockEvents(false);
}
});
- animSet.setDuration(250);
- animSet.start();
+ combo.start();
}
private void finishAnimateOut() {
@@ -431,7 +445,7 @@
if (mNavScreen == null) {
showNavScreen();
} else {
- hideNavScreen(false);
+ hideNavScreen(mUiController.getTabControl().getCurrentPosition(), false);
}
}
@@ -477,6 +491,8 @@
public AnimScreen(Context ctx, Bitmap image) {
mMain = LayoutInflater.from(ctx).inflate(R.layout.anim_screen,
null);
+ mTitle = (ImageView) mMain.findViewById(R.id.title);
+ mTitle.setVisibility(View.GONE);
mContent = (ImageView) mMain.findViewById(R.id.content);
mContent.setImageBitmap(image);
mContent.setScaleType(ImageView.ScaleType.MATRIX);
diff --git a/src/com/android/browser/Tab.java b/src/com/android/browser/Tab.java
index 8c9dc02..96920a4 100644
--- a/src/com/android/browser/Tab.java
+++ b/src/com/android/browser/Tab.java
@@ -32,7 +32,10 @@
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
+import android.graphics.Paint;
import android.graphics.Picture;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
import android.net.Uri;
import android.net.http.SslError;
import android.os.Bundle;
@@ -66,8 +69,6 @@
import android.webkit.WebView.PictureListener;
import android.webkit.WebViewClient;
import android.widget.CheckBox;
-import android.widget.LinearLayout;
-import android.widget.TextView;
import android.widget.Toast;
import com.android.browser.TabControl.OnThumbnailUpdatedListener;
@@ -105,6 +106,12 @@
private static Bitmap sDefaultFavicon;
+ private static Paint sAlphaPaint = new Paint();
+ static {
+ sAlphaPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+ sAlphaPaint.setColor(Color.TRANSPARENT);
+ }
+
public enum LockIcon {
LOCK_ICON_UNSECURE,
LOCK_ICON_SECURE,
@@ -2050,6 +2057,7 @@
Canvas c = new Canvas(mCapture);
final int left = mMainView.getScrollX();
final int top = mMainView.getScrollY() + mMainView.getVisibleTitleHeight();
+ int state = c.save();
c.translate(-left, -top);
float scale = mCaptureWidth / (float) mMainView.getWidth();
c.scale(scale, scale, left, top);
@@ -2058,6 +2066,14 @@
} else {
mMainView.draw(c);
}
+ c.restoreToCount(state);
+ // manually anti-alias the edges for the tilt
+ c.drawRect(0, 0, 1, mCapture.getHeight(), sAlphaPaint);
+ c.drawRect(mCapture.getWidth() - 1, 0, mCapture.getWidth(),
+ mCapture.getHeight(), sAlphaPaint);
+ c.drawRect(0, 0, mCapture.getWidth(), 1, sAlphaPaint);
+ c.drawRect(0, mCapture.getHeight() - 1, mCapture.getWidth(),
+ mCapture.getHeight(), sAlphaPaint);
c.setBitmap(null);
mHandler.removeMessages(MSG_CAPTURE);
persistThumbnail();
diff --git a/src/com/android/browser/view/Gallery.java b/src/com/android/browser/view/Gallery.java
deleted file mode 100644
index 2e2c75f..0000000
--- a/src/com/android/browser/view/Gallery.java
+++ /dev/null
@@ -1,1531 +0,0 @@
-/*
- * Copyright (C) 2011 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 com.android.browser.view;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.database.DataSetObserver;
-import android.graphics.Rect;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.util.SparseArray;
-import android.view.GestureDetector;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.MotionEvent;
-import android.view.SoundEffectConstants;
-import android.view.View;
-import android.view.ViewConfiguration;
-import android.view.ViewGroup;
-import android.view.animation.BounceInterpolator;
-import android.view.animation.DecelerateInterpolator;
-import android.view.animation.Transformation;
-import android.widget.BaseAdapter;
-import android.widget.LinearLayout;
-import android.widget.Scroller;
-
-import com.android.internal.R;
-
-public class Gallery extends ViewGroup implements
- GestureDetector.OnGestureListener {
-
- private static final String TAG = "Gallery";
-
- private static final boolean localLOGV = false;
-
- private static final int INVALID_POSITION = -1;
-
- /**
- * Duration in milliseconds from the start of a scroll during which we're
- * unsure whether the user is scrolling or flinging.
- */
- private static final int SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT = 250;
- private static final int INVALID_POINTER = -1;
-
- private boolean mInLayout;
- private int mWidthMeasureSpec;
- private int mHeightMeasureSpec;
- private boolean mBlockLayoutRequests;
-
- private Rect mTouchFrame;
-
- private RecycleBin mRecycler;
-
- protected boolean mHorizontal;
- protected int mFirstPosition;
- private int mItemCount;
- private boolean mDataChanged;
-
- protected BaseAdapter mAdapter;
-
- private int mSelectedPosition;
- private int mOldSelectedPosition;
-
- private int mSpacing = 0;
- private int mAnimationDuration = 400;
- private float mUnselectedAlpha;
- private int mLeftMost;
- private int mRightMost;
- private int mGravity;
-
- private GestureDetector mGestureDetector;
-
- protected int mDownTouchPosition;
- protected View mDownTouchView;
- private FlingRunnable mFlingRunnable = new FlingRunnable();
-
- private OnItemSelectedListener mOnItemSelectedListener;
- private SelectionNotifier mSelectionNotifier;
-
- private int mGapPosition;
- private int mGap;
- private Animator mGapAnimator;
-
- /**
- * Sets mSuppressSelectionChanged = false. This is used to set it to false
- * in the future. It will also trigger a selection changed.
- */
- private Runnable mDisableSuppressSelectionChangedRunnable = new Runnable() {
- public void run() {
- mSuppressSelectionChanged = false;
- selectionChanged();
- }
- };
-
- private boolean mShouldStopFling;
- private View mSelectedChild;
- private boolean mShouldCallbackDuringFling = true;
- private boolean mShouldCallbackOnUnselectedItemClick = true;
- private boolean mSuppressSelectionChanged;
- private boolean mReceivedInvokeKeyDown;
-
- /**
- * If true, this onScroll is the first for this user's drag (remember, a
- * drag sends many onScrolls).
- */
- private boolean mIsFirstScroll;
-
- private boolean mIsBeingDragged;
- protected boolean mIsOrthoDragged;
-
- private int mActivePointerId = INVALID_POINTER;
-
- private int mTouchSlop;
-
- private float mLastMotionCoord;
- private float mLastOrthoCoord;
-
- private int mScrollValue;
-
- public Gallery(Context context) {
- this(context, null);
- }
-
- public Gallery(Context context, AttributeSet attrs) {
- this(context, attrs, R.attr.galleryStyle);
- }
-
- public Gallery(Context context, AttributeSet attrs, int defStyle) {
- super(context, attrs, defStyle);
- mRecycler = new RecycleBin();
- mGestureDetector = new GestureDetector(context, this);
- mGestureDetector.setIsLongpressEnabled(true);
- TypedArray a = context.obtainStyledAttributes(attrs,
- com.android.internal.R.styleable.Gallery, defStyle, 0);
- int index = a.getInt(com.android.internal.R.styleable.Gallery_gravity,
- -1);
- if (index >= 0) {
- setGravity(index);
- }
- int animationDuration = a.getInt(
- com.android.internal.R.styleable.Gallery_animationDuration, -1);
- if (animationDuration > 0) {
- setAnimationDuration(animationDuration);
- }
- float unselectedAlpha = a.getFloat(
- com.android.internal.R.styleable.Gallery_unselectedAlpha, 0.5f);
- setUnselectedAlpha(unselectedAlpha);
- mHorizontal = true;
- a.recycle();
- // We draw the selected item last (because otherwise the item to the
- // right overlaps it)
- mGroupFlags |= FLAG_USE_CHILD_DRAWING_ORDER;
- mGroupFlags |= FLAG_SUPPORT_STATIC_TRANSFORMATIONS;
- final ViewConfiguration configuration = ViewConfiguration.get(mContext);
- mTouchSlop = configuration.getScaledTouchSlop();
- setFocusable(true);
- setWillNotDraw(false);
- mGapPosition = INVALID_POSITION;
- mGap = 0;
- // proguard
- setGap(getGap());
- setScrollValue(getScrollValue());
- }
-
- /**
- * Interface definition for a callback to be invoked when an item in this
- * view has been selected.
- */
- public interface OnItemSelectedListener {
- void onItemSelected(ViewGroup parent, View view, int position, long id);
- }
-
- public interface OnScrollFinishedListener {
- void onScrollFinished();
- }
-
- /**
- * Register a callback to be invoked when an item in this AdapterView has
- * been selected.
- *
- * @param listener
- * The callback that will run
- */
- public void setOnItemSelectedListener(OnItemSelectedListener listener) {
- mOnItemSelectedListener = listener;
- }
-
- public final OnItemSelectedListener getOnItemSelectedListener() {
- return mOnItemSelectedListener;
- }
-
- public void setOrientation(int orientation) {
- mHorizontal = (orientation == LinearLayout.HORIZONTAL);
- requestLayout();
- }
-
- /**
- * define a visual gap in the list of items
- * the gap is rendered in front (left or above)
- * the given position
- * @param position
- * @param gap
- */
- public void setGapPosition(int position, int gap) {
- mGapPosition = position;
- mGap = gap;
- }
-
- public void setGap(int gap) {
- if (mGapPosition != INVALID_POSITION) {
- mGap = gap;
- layout(0, false);
- }
- }
-
- public int getGap() {
- return mGap;
- }
-
- public void setAdapter(BaseAdapter adapter, int selpos) {
- mSelectedPosition = selpos;
- setAdapter(adapter);
- }
-
- public void setAdapter(BaseAdapter adapter) {
- mAdapter = adapter;
- if (mAdapter != null) {
- mAdapter.registerDataSetObserver(new DataSetObserver() {
- @Override
- public void onChanged() {
- super.onChanged();
- mDataChanged = true;
- handleDataChanged();
- }
-
- @Override
- public void onInvalidated() {
- super.onInvalidated();
- }
- });
- }
- handleDataChanged();
- }
-
- public void handleDataChanged() {
- if (mAdapter != null) {
- if (mGapAnimator != null) {
- mGapAnimator.cancel();
- }
- resetList();
- mItemCount = mAdapter.getCount();
- // checkFocus();
- if (mItemCount > 0) {
- int position = 0;
- if (mSelectedPosition >= 0) {
- position = Math.min(mItemCount - 1, mSelectedPosition);
- }
- setSelectedPositionInt(position);
- if (mGapPosition > INVALID_POSITION) {
- mGapAnimator = ObjectAnimator.ofInt(this, "gap", mGap, 0);
- mGapAnimator.setDuration(250);
- mGapAnimator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator a) {
- mGapPosition = INVALID_POSITION;
- mGap = 0;
- mGapAnimator = null;
- }
- });
- mGapAnimator.start();
- } else {
- layout(0, false);
- }
- }
- } else {
- // checkFocus();
- mOldSelectedPosition = INVALID_POSITION;
- setSelectedPositionInt(INVALID_POSITION);
- resetList();
- // Nothing selected
- checkSelectionChanged();
- invalidate();
- }
- }
-
- /**
- * Clear out all children from the list
- */
- void resetList() {
- mDataChanged = false;
- removeAllViewsInLayout();
- }
-
- public void setCallbackDuringFling(boolean shouldCallback) {
- mShouldCallbackDuringFling = shouldCallback;
- }
-
- public void setCallbackOnUnselectedItemClick(boolean shouldCallback) {
- mShouldCallbackOnUnselectedItemClick = shouldCallback;
- }
-
- public void setAnimationDuration(int animationDurationMillis) {
- mAnimationDuration = animationDurationMillis;
- }
-
- public void setUnselectedAlpha(float unselectedAlpha) {
- mUnselectedAlpha = unselectedAlpha;
- }
-
- @Override
- protected boolean getChildStaticTransformation(View child, Transformation t) {
- return false;
- }
-
- @Override
- protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
- return p instanceof LayoutParams;
- }
-
- @Override
- protected ViewGroup.LayoutParams generateLayoutParams(
- ViewGroup.LayoutParams p) {
- return new LayoutParams(p);
- }
-
- @Override
- public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
- return new LayoutParams(getContext(), attrs);
- }
-
- @Override
- protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
- return new Gallery.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
- ViewGroup.LayoutParams.WRAP_CONTENT);
- }
-
- @Override
- protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
- int widthMode = MeasureSpec.getMode(widthMeasureSpec);
- int widthSize;
- int heightSize;
- if (mDataChanged) {
- handleDataChanged();
- }
- int preferredHeight = 0;
- int preferredWidth = 0;
- boolean needsMeasuring = true;
- int selectedPosition = getSelectedItemPosition();
- if (selectedPosition >= 0 && mAdapter != null
- && selectedPosition < mAdapter.getCount()) {
- // Try looking in the recycler. (Maybe we were measured once
- // already)
- View view = mRecycler.get(selectedPosition);
- if (view == null) {
- // Make a new one
- view = mAdapter.getView(selectedPosition, null, this);
- }
- if (view != null) {
- // Put in recycler for re-measuring and/or layout
- mRecycler.put(selectedPosition, view);
- }
- if (view != null) {
- if (view.getLayoutParams() == null) {
- mBlockLayoutRequests = true;
- view.setLayoutParams(generateDefaultLayoutParams());
- mBlockLayoutRequests = false;
- }
- measureChild(view, widthMeasureSpec, heightMeasureSpec);
- preferredHeight = getChildHeight(view);
- preferredWidth = getChildWidth(view);
- needsMeasuring = false;
- }
- }
- if (needsMeasuring) {
- // No views -- just use padding
- preferredHeight = 0;
- if (widthMode == MeasureSpec.UNSPECIFIED) {
- preferredWidth = 0;
- }
- }
- preferredHeight = Math
- .max(preferredHeight, getSuggestedMinimumHeight());
- preferredWidth = Math.max(preferredWidth, getSuggestedMinimumWidth());
- heightSize = resolveSizeAndState(preferredHeight, heightMeasureSpec, 0);
- widthSize = resolveSizeAndState(preferredWidth, widthMeasureSpec, 0);
- setMeasuredDimension(widthSize, heightSize);
- mHeightMeasureSpec = heightMeasureSpec;
- mWidthMeasureSpec = widthMeasureSpec;
- }
-
- @Override
- public void requestLayout() {
- if (!mBlockLayoutRequests) {
- super.requestLayout();
- }
- }
-
- @Override
- protected void onLayout(boolean changed, int l, int t, int r, int b) {
- mInLayout = true;
- layout(0, false);
- mInLayout = false;
- }
-
- int getChildHeight(View child) {
- return child.getMeasuredHeight();
- }
-
- int getChildWidth(View child) {
- return child.getMeasuredWidth();
- }
-
- /**
- * Tracks a motion scroll. In reality, this is used to do just about any
- * movement to items (touch scroll, arrow-key scroll, set an item as
- * selected).
- *
- * @param deltaX
- * Change in X from the previous event.
- */
- protected void trackMotionScroll(int deltaX) {
- if (getChildCount() == 0) {
- return;
- }
- boolean toLeft = deltaX < 0;
- int limitedDeltaX = mFlingRunnable.mScroller.isFinished()
- ? deltaX : getLimitedMotionScrollAmount(toLeft, deltaX);
- if (limitedDeltaX != deltaX) {
- // The above call returned a limited amount, so stop any
- // scrolls/flings
- mFlingRunnable.endFling(false);
- onFinishedMovement();
- }
- offsetChildrenLeftAndRight(limitedDeltaX);
- detachOffScreenChildren(toLeft);
- if (toLeft) {
- // If moved left, there will be empty space on the right
- fillToGalleryRight();
- } else {
- // Similarly, empty space on the left
- fillToGalleryLeft();
- }
- setSelectionToCenterChild();
- invalidate();
- }
-
- int getLimitedMotionScrollAmount(boolean motionToLeft, int deltaX) {
- int extremeItemPosition = motionToLeft ? mItemCount - 1 : 0;
- View extremeChild = getChildAt(extremeItemPosition - mFirstPosition);
- if (extremeChild == null) {
- return deltaX;
- }
- int extremeChildCenter = getCenterOfView(extremeChild);
- int galleryCenter = getCenterOfGallery();
- if (motionToLeft) {
- if (extremeChildCenter <= galleryCenter) {
- return 0;
- }
- } else {
- if (extremeChildCenter >= galleryCenter) {
- return 0;
- }
- }
- int centerDifference = galleryCenter - extremeChildCenter;
- return motionToLeft ? Math.max(centerDifference, deltaX) : Math.min(
- centerDifference, deltaX);
- }
-
- /**
- * Offset the horizontal location of all children of this view by the
- * specified number of pixels.
- *
- * @param offset
- * the number of pixels to offset
- */
- private void offsetChildrenLeftAndRight(int offset) {
- for (int i = getChildCount() - 1; i >= 0; i--) {
- if (mHorizontal) {
- getChildAt(i).offsetLeftAndRight(offset);
- } else {
- getChildAt(i).offsetTopAndBottom(offset);
- }
- }
- }
-
- /**
- * @return The center of this Gallery.
- */
- private int getCenterOfGallery() {
- return (mHorizontal ? (getWidth() - mPaddingLeft - mPaddingRight) / 2
- + mPaddingLeft : (getHeight() - mPaddingTop - mPaddingBottom)
- / 2 + mPaddingTop);
- }
-
- /**
- * @return The center of the given view.
- */
- private int getCenterOfView(View view) {
- return (mHorizontal ? view.getLeft() + view.getWidth() / 2 : view
- .getTop() + view.getHeight() / 2);
- }
-
- /**
- * Detaches children that are off the screen (i.e.: Gallery bounds).
- *
- * @param toLeft
- * Whether to detach children to the left of the Gallery, or to
- * the right.
- */
- private void detachOffScreenChildren(boolean toLeft) {
- int numChildren = getChildCount();
- int firstPosition = mFirstPosition;
- int start = 0;
- int count = 0;
- if (toLeft) {
- final int galleryLeft = (mHorizontal ? mPaddingLeft : mPaddingTop);
- for (int i = 0; i < numChildren; i++) {
- final View child = getChildAt(i);
- if ((mHorizontal && (child.getRight() >= galleryLeft))
- || (!mHorizontal && (child.getBottom() >= galleryLeft))) {
- break;
- } else {
- count++;
- mRecycler.put(firstPosition + i, child);
- }
- }
- } else {
- final int galleryRight = (mHorizontal ? getWidth() - mPaddingRight
- : getHeight() - mPaddingBottom);
- for (int i = numChildren - 1; i >= 0; i--) {
- final View child = getChildAt(i);
- if ((mHorizontal && (child.getLeft() <= galleryRight))
- || (!mHorizontal && (child.getTop() <= galleryRight))) {
- break;
- } else {
- start = i;
- count++;
- mRecycler.put(firstPosition + i, child);
- }
- }
- }
- detachViewsFromParent(start, count);
- if (toLeft) {
- mFirstPosition += count;
- }
- }
-
- private void scrollIntoSlots() {
- if (getChildCount() == 0 || mSelectedChild == null)
- return;
- int selectedCenter = getCenterOfView(mSelectedChild);
- int targetCenter = getCenterOfGallery();
- int scrollAmount = targetCenter - selectedCenter;
- if (scrollAmount != 0) {
- mFlingRunnable.startUsingDistance(scrollAmount);
- } else {
- onFinishedMovement();
- }
- }
-
- private void onFinishedMovement() {
- if (mSuppressSelectionChanged) {
- mSuppressSelectionChanged = false;
- // We haven't sent callbacks during the fling, so do it now
- selectionChanged();
- }
- invalidate();
- }
-
- protected void setSelectionToCenterChild() {
- if (mSelectedChild == null)
- return;
- int galleryCenter = getCenterOfGallery();
- int lastDistance = Integer.MAX_VALUE;
- int newSelectedChildIndex = 0;
- for (int i = getChildCount() - 1; i >= 0; i--) {
- View child = getChildAt(i);
- int distance = Math.abs(getCenterOfView(child) - galleryCenter);
- if (distance > lastDistance) {
- // we're moving away from the center, done
- break;
- } else {
- newSelectedChildIndex = i;
- lastDistance = distance;
- }
- }
- int newPos = mFirstPosition + newSelectedChildIndex;
- if (newPos != mSelectedPosition) {
- setSelectedPositionInt(newPos);
- checkSelectionChanged();
- }
- }
-
- /**
- * Creates and positions all views for this Gallery.
- * <p>
- * We layout rarely, most of the time {@link #trackMotionScroll(int)} takes
- * care of repositioning, adding, and removing children.
- *
- * @param delta
- * Change in the selected position. +1 means the selection is
- * moving to the right, so views are scrolling to the left. -1
- * means the selection is moving to the left.
- */
- void layout(int delta, boolean animate) {
- int childrenLeft = 0;
- int childrenWidth = (mHorizontal ? mRight - mLeft : mBottom - mTop);
- if (mDataChanged) {
- handleDataChanged();
- }
- if (mItemCount == 0) {
- mOldSelectedPosition = INVALID_POSITION;
- setSelectedPositionInt(INVALID_POSITION);
- resetList();
- return;
- }
- if (mSelectedPosition >= 0) {
- setSelectedPositionInt(mSelectedPosition);
- }
- recycleAllViews();
- detachAllViewsFromParent();
- mRightMost = 0;
- mLeftMost = 0;
- mFirstPosition = mSelectedPosition;
- View sel = makeAndAddView(mSelectedPosition, 0, 0, true);
- // Put the selected child in the center
- int selectedOffset = childrenLeft + (childrenWidth / 2)
- - (mHorizontal ? (sel.getWidth() / 2) : (sel.getHeight() / 2));
- if (mHorizontal) {
- sel.offsetLeftAndRight(selectedOffset);
- } else {
- sel.offsetTopAndBottom(selectedOffset);
- }
- fillToGalleryRight();
- fillToGalleryLeft();
- if (mGapPosition > INVALID_POSITION) {
- adjustGap();
- }
- mRecycler.clear();
- invalidate();
- checkSelectionChanged();
- mDataChanged = false;
- updateSelectedItemMetadata();
- }
-
- void adjustGap() {
- for (int i = 0; i < getChildCount(); i++) {
- int pos = i + mFirstPosition;
- if (pos >= mGapPosition) {
- if (mHorizontal) {
- getChildAt(i).offsetLeftAndRight(mGap);
- } else {
- getChildAt(i).offsetTopAndBottom(mGap);
- }
- }
- }
- }
-
- void recycleAllViews() {
- final int childCount = getChildCount();
- final RecycleBin recycleBin = mRecycler;
- final int position = mFirstPosition;
- for (int i = 0; i < childCount; i++) {
- View v = getChildAt(i);
- int index = position + i;
- recycleBin.put(index, v);
- }
- }
-
- private void fillToGalleryLeft() {
- int itemSpacing = mSpacing;
- int galleryLeft = mHorizontal ? mPaddingLeft : mPaddingTop;
- View prevIterationView = getChildAt(0);
- int curPosition;
- int curRightEdge;
- if (prevIterationView != null) {
- curPosition = mFirstPosition - 1;
- curRightEdge = (mHorizontal ? prevIterationView.getLeft()
- : prevIterationView.getTop()) - itemSpacing;
- } else {
- // No children available!
- curPosition = 0;
- curRightEdge = (mHorizontal ? mRight - mLeft - mPaddingRight
- : mBottom - mTop - mPaddingBottom);
- mShouldStopFling = true;
- }
- while (curRightEdge > galleryLeft && curPosition >= 0) {
- prevIterationView = makeAndAddView(curPosition, curPosition
- - mSelectedPosition, curRightEdge, false);
- // Remember some state
- mFirstPosition = curPosition;
- // Set state for next iteration
- curRightEdge = (mHorizontal ? prevIterationView.getLeft()
- - itemSpacing : prevIterationView.getTop() - itemSpacing);
- curPosition--;
- }
- }
-
- private void fillToGalleryRight() {
- int itemSpacing = mSpacing;
- int galleryRight = (mHorizontal ? mRight - mLeft - mPaddingRight
- : mBottom - mTop - mPaddingBottom);
- int numChildren = getChildCount();
- int numItems = mItemCount;
- View prevIterationView = getChildAt(numChildren - 1);
- int curPosition;
- int curLeftEdge;
- if (prevIterationView != null) {
- curPosition = mFirstPosition + numChildren;
- curLeftEdge = mHorizontal ? prevIterationView.getRight()
- + itemSpacing : prevIterationView.getBottom() + itemSpacing;
- } else {
- mFirstPosition = curPosition = mItemCount - 1;
- curLeftEdge = mHorizontal ? mPaddingLeft : mPaddingTop;
- mShouldStopFling = true;
- }
- while (curLeftEdge < galleryRight && curPosition < numItems) {
- prevIterationView = makeAndAddView(curPosition, curPosition
- - mSelectedPosition, curLeftEdge, true);
-
- // Set state for next iteration
- curLeftEdge = mHorizontal ? prevIterationView.getRight()
- + itemSpacing : prevIterationView.getBottom() + itemSpacing;
- curPosition++;
- }
- }
-
- /**
- * Obtain a view, either by pulling an existing view from the recycler or by
- * getting a new one from the adapter. If we are animating, make sure there
- * is enough information in the view's layout parameters to animate from the
- * old to new positions.
- *
- * @param position
- * Position in the gallery for the view to obtain
- * @param offset
- * Offset from the selected position
- * @param x
- * X-coordintate indicating where this view should be placed.
- * This will either be the left or right edge of the view,
- * depending on the fromLeft paramter
- * @param fromLeft
- * Are we positioning views based on the left edge? (i.e.,
- * building from left to right)?
- * @return A view that has been added to the gallery
- */
- private View makeAndAddView(int position, int offset, int x,
- boolean fromLeft) {
- View child;
- if (!mDataChanged) {
- child = mRecycler.get(position);
- if (child != null) {
- // Can reuse an existing view
- int childLeft = mHorizontal ? child.getLeft() : child.getTop();
-
- // Remember left and right edges of where views have been placed
- mRightMost = Math.max(mRightMost,
- childLeft
- + (mHorizontal ? child.getMeasuredWidth()
- : child.getMeasuredHeight()));
- mLeftMost = Math.min(mLeftMost, childLeft);
-
- // Position the view
- setUpChild(position, child, offset, x, fromLeft);
-
- return child;
- }
- }
- // Nothing found in the recycler -- ask the adapter for a view
- child = mAdapter.getView(position, null, this);
- // Position the view
- setUpChild(position, child, offset, x, fromLeft);
- return child;
- }
-
- /**
- * Helper for makeAndAddView to set the position of a view and fill out its
- * layout paramters.
- *
- * @param child
- * The view to position
- * @param offset
- * Offset from the selected position
- * @param x
- * X-coordintate indicating where this view should be placed.
- * This will either be the left or right edge of the view,
- * depending on the fromLeft paramter
- * @param fromLeft
- * Are we positioning views based on the left edge? (i.e.,
- * building from left to right)?
- */
- private void setUpChild(int position, View child, int offset, int x,
- boolean fromLeft) {
- Gallery.LayoutParams lp = (Gallery.LayoutParams) child
- .getLayoutParams();
- if (lp == null) {
- lp = (Gallery.LayoutParams) generateDefaultLayoutParams();
- }
- addViewInLayout(child, fromLeft ? -1 : 0, lp);
- child.setSelected(offset == 0);
- int childHeightSpec = ViewGroup.getChildMeasureSpec(mHeightMeasureSpec,
- 0, lp.height);
- int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec,
- 0, lp.width);
- child.measure(childWidthSpec, childHeightSpec);
- int childLeft;
- int childRight;
- // Position vertically based on gravity setting
- int childTop = calculateTop(child, true);
- int childBottom = childTop
- + (mHorizontal ? child.getMeasuredHeight() : child
- .getMeasuredWidth());
- int width = mHorizontal ? child.getMeasuredWidth() : child
- .getMeasuredHeight();
- if (fromLeft) {
- childLeft = x;
- childRight = childLeft + width;
- } else {
- childLeft = x - width;
- childRight = x;
- }
- if (mHorizontal) {
- child.layout(childLeft, childTop, childRight, childBottom);
- } else {
- child.layout(childTop, childLeft, childBottom, childRight);
- }
- }
-
- /**
- * Figure out vertical placement based on mGravity
- *
- * @param child
- * Child to place
- * @return Where the top of the child should be
- */
- protected int calculateTop(View child, boolean duringLayout) {
- int myHeight = mHorizontal ? (duringLayout ? getMeasuredHeight()
- : getHeight()) : (duringLayout ? getMeasuredWidth()
- : getWidth());
- int childHeight = mHorizontal ? (duringLayout ? child
- .getMeasuredHeight() : child.getHeight())
- : (duringLayout ? child.getMeasuredWidth() : child.getWidth());
- int childTop = 0;
- switch (mGravity) {
- case Gravity.TOP:
- case Gravity.LEFT:
- childTop = 0;
- break;
- case Gravity.CENTER_VERTICAL:
- case Gravity.CENTER_HORIZONTAL:
- int availableSpace = myHeight - childHeight;
- childTop = availableSpace / 2;
- break;
- case Gravity.BOTTOM:
- case Gravity.RIGHT:
- childTop = myHeight - childHeight;
- break;
- }
- return childTop;
- }
-
- @Override
- public boolean onInterceptTouchEvent(MotionEvent ev) {
- /*
- * 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 ((action == MotionEvent.ACTION_MOVE) && (mIsOrthoDragged)) {
- return true;
- }
- switch (action & MotionEvent.ACTION_MASK) {
- 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.
- */
- final int activePointerId = mActivePointerId;
- if (activePointerId == INVALID_POINTER) {
- // If we don't have a valid id, the touch down wasn't on
- // content.
- break;
- }
- final int pointerIndex = ev.findPointerIndex(activePointerId);
- final float coord = mHorizontal ? ev.getX(pointerIndex) : ev
- .getY(pointerIndex);
-
- final int diff = (int) Math.abs(coord - mLastMotionCoord);
- if (diff > mTouchSlop) {
- mIsBeingDragged = true;
- mLastMotionCoord = coord;
- } else {
- final float ocoord = mHorizontal ? ev.getY(pointerIndex)
- : ev.getX(pointerIndex);
- if (Math.abs(ocoord - mLastOrthoCoord) > mTouchSlop) {
- mIsOrthoDragged = true;
- mLastOrthoCoord = ocoord;
- }
- }
- if (mIsBeingDragged || mIsOrthoDragged) {
- if (mParent != null)
- mParent.requestDisallowInterceptTouchEvent(true);
- }
- break;
- }
- case MotionEvent.ACTION_DOWN: {
- final float coord = mHorizontal ? ev.getX() : ev.getY();
- /*
- * Remember location of down touch. ACTION_DOWN always refers to
- * pointer index 0.
- */
- mLastMotionCoord = coord;
- mActivePointerId = ev.getPointerId(0);
- /*
- * If being flinged and user touches the screen, initiate drag;
- * otherwise don't. mScroller.isFinished should be false when being
- * flinged.
- */
- mIsBeingDragged = !mFlingRunnable.mScroller.isFinished();
- mIsOrthoDragged = false;
- final float ocoord = mHorizontal ? ev.getY() : ev.getX();
- mLastOrthoCoord = ocoord;
- mGestureDetector.onTouchEvent(ev);
- break;
- }
- case MotionEvent.ACTION_CANCEL:
- case MotionEvent.ACTION_UP:
- /* Release the drag */
- mIsBeingDragged = false;
- mIsOrthoDragged = false;
- mActivePointerId = INVALID_POINTER;
- break;
- case MotionEvent.ACTION_POINTER_DOWN: {
- final int index = ev.getActionIndex();
- mLastMotionCoord = mHorizontal ? ev.getX(index) : ev.getY(index);
- mLastOrthoCoord = mHorizontal ? ev.getY(index) : ev.getX(index);
- mActivePointerId = ev.getPointerId(index);
- break;
- }
- case MotionEvent.ACTION_POINTER_UP:
- mLastMotionCoord = mHorizontal ? ev.getX(ev.findPointerIndex(mActivePointerId))
- : ev.getY(ev.findPointerIndex(mActivePointerId));
- mLastOrthoCoord = mHorizontal ? ev.getY(ev.findPointerIndex(mActivePointerId))
- : ev.getX(ev.findPointerIndex(mActivePointerId));
- break;
- }
- return mIsBeingDragged || mIsOrthoDragged;
- }
-
- @Override
- public boolean onTouchEvent(MotionEvent event) {
- // Give everything to the gesture detector
- boolean retValue = mGestureDetector.onTouchEvent(event);
- int action = event.getAction();
- if (action == MotionEvent.ACTION_UP) {
- // Helper method for lifted finger
- onUp(mDownTouchView);
- } else if (action == MotionEvent.ACTION_CANCEL) {
- onCancel();
- }
- return retValue;
- }
-
- public boolean onSingleTapUp(MotionEvent e) {
- if (mDownTouchPosition >= 0) {
- // An item tap should make it selected, so scroll to this child.
- scrollToChild(mDownTouchPosition - mFirstPosition);
- if (mShouldCallbackOnUnselectedItemClick
- || mDownTouchPosition == mSelectedPosition) {
- performItemClick(mDownTouchView, mDownTouchPosition,
- mAdapter.getItemId(mDownTouchPosition));
- }
- return true;
- }
- return false;
- }
-
- public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
- float velocityY) {
- if (!mShouldCallbackDuringFling) {
- removeCallbacks(mDisableSuppressSelectionChangedRunnable);
- if (!mSuppressSelectionChanged)
- mSuppressSelectionChanged = true;
- }
- if (isOrthoMove(velocityX, velocityY)) {
- onOrthoFling(mDownTouchView, e1, e2, mHorizontal ? velocityY : velocityX);
- return true;
- }
- mFlingRunnable.startUsingVelocity(mHorizontal ? (int) -velocityX
- : (int) -velocityY);
- return true;
- }
-
- public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
- float distanceY) {
- if (localLOGV)
- Log.v(TAG, String.valueOf(e2.getX() - e1.getX()));
- mParent.requestDisallowInterceptTouchEvent(true);
- if (mIsOrthoDragged && isOrthoMove(distanceX, distanceY)) {
- onOrthoDrag(mDownTouchView, e1, e2, mHorizontal ? distanceY : distanceX);
- } else if (mIsBeingDragged) {
- if (!mShouldCallbackDuringFling) {
- if (mIsFirstScroll) {
- if (!mSuppressSelectionChanged) {
- mSuppressSelectionChanged = true;
- }
- postDelayed(mDisableSuppressSelectionChangedRunnable,
- SCROLL_TO_FLING_UNCERTAINTY_TIMEOUT);
- }
- } else {
- if (mSuppressSelectionChanged) {
- mSuppressSelectionChanged = false;
- }
- }
- trackMotionScroll(mHorizontal ? -1 * (int) distanceX : -1
- * (int) distanceY);
-
- mIsFirstScroll = false;
- }
- return true;
- }
-
- protected void onOrthoDrag(View draggedView, MotionEvent down,
- MotionEvent move, float distance) {
- }
-
- protected void onOrthoFling(View draggedView, MotionEvent down,
- MotionEvent move, float velocity) {
- }
-
- public boolean onDown(MotionEvent e) {
- mFlingRunnable.stop(false);
- mDownTouchPosition = pointToPosition((int) e.getX(), (int) e.getY());
- if (mDownTouchPosition >= 0) {
- mDownTouchView = getChildAt(mDownTouchPosition - mFirstPosition);
- }
- // Reset the multiple-scroll tracking state
- mIsFirstScroll = true;
- // Must return true to get matching events for this down event.
- return true;
- }
-
- /**
- * Called when a touch event's action is MotionEvent.ACTION_UP.
- */
- protected void onUp(View downView) {
- if (mFlingRunnable.mScroller.isFinished()) {
- scrollIntoSlots();
- }
- dispatchUnpress();
- }
-
- private boolean isOrthoMove(float moveX, float moveY) {
- return mHorizontal && Math.abs(moveY) > Math.abs(moveX)
- || !mHorizontal && Math.abs(moveX) > Math.abs(moveY);
- }
-
- /**
- * Called when a touch event's action is MotionEvent.ACTION_CANCEL.
- */
- void onCancel() {
- onUp(mDownTouchView);
- }
-
- public void onLongPress(MotionEvent e) {
- }
-
- public void onShowPress(MotionEvent e) {
- }
-
- private void dispatchPress(View child) {
- if (child != null) {
- child.setPressed(true);
- }
- setPressed(true);
- }
-
- private void dispatchUnpress() {
- for (int i = getChildCount() - 1; i >= 0; i--) {
- getChildAt(i).setPressed(false);
- }
- setPressed(false);
- }
-
- @Override
- public void dispatchSetSelected(boolean selected) {
- }
-
- @Override
- protected void dispatchSetPressed(boolean pressed) {
- }
-
- @Override
- public boolean dispatchKeyEvent(KeyEvent event) {
- return event.dispatch(this, null, null);
- }
-
- /**
- * Handles left, right, and clicking
- *
- * @see android.view.View#onKeyDown
- */
- @Override
- public boolean onKeyDown(int keyCode, KeyEvent event) {
- switch (keyCode) {
-
- case KeyEvent.KEYCODE_DPAD_LEFT:
- if (movePrevious()) {
- playSoundEffect(SoundEffectConstants.NAVIGATION_LEFT);
- }
- return true;
-
- case KeyEvent.KEYCODE_DPAD_RIGHT:
- if (moveNext()) {
- playSoundEffect(SoundEffectConstants.NAVIGATION_RIGHT);
- }
- return true;
-
- case KeyEvent.KEYCODE_DPAD_CENTER:
- case KeyEvent.KEYCODE_ENTER:
- mReceivedInvokeKeyDown = true;
- // fallthrough to default handling
- }
-
- return super.onKeyDown(keyCode, event);
- }
-
- @Override
- public boolean onKeyUp(int keyCode, KeyEvent event) {
- switch (keyCode) {
- case KeyEvent.KEYCODE_DPAD_CENTER:
- case KeyEvent.KEYCODE_ENTER: {
-
- if (mReceivedInvokeKeyDown) {
- if (mItemCount > 0) {
-
- dispatchPress(mSelectedChild);
- postDelayed(new Runnable() {
- public void run() {
- dispatchUnpress();
- }
- }, ViewConfiguration.getPressedStateDuration());
-
- int selectedIndex = mSelectedPosition - mFirstPosition;
- performItemClick(getChildAt(selectedIndex),
- mSelectedPosition,
- mAdapter.getItemId(mSelectedPosition));
- }
- }
-
- // Clear the flag
- mReceivedInvokeKeyDown = false;
-
- return true;
- }
- }
-
- return super.onKeyUp(keyCode, event);
- }
-
- private void performItemClick(View childAt, int mSelectedPosition2,
- long itemId) {
- }
-
- protected boolean movePrevious() {
- if (mItemCount > 0 && mSelectedPosition > 0) {
- scrollToChild(mSelectedPosition - mFirstPosition - 1);
- return true;
- } else {
- return false;
- }
- }
-
- public boolean moveNext() {
- if (mItemCount > 0 && mSelectedPosition < mItemCount - 1) {
- scrollToChild(mSelectedPosition - mFirstPosition + 1);
- return true;
- } else {
- return false;
- }
- }
-
- public boolean scrollToChild(int childPosition) {
- View child = getChildAt(childPosition);
- if (child != null) {
- int distance = getCenterOfGallery() - getCenterOfView(child);
- mFlingRunnable.startUsingDistance(distance, 0);
- return true;
- }
- return false;
- }
-
- /**
- * use the scroller to scroll to a new position, independent
- * of whether attached or not
- * this uses trackMotionScroll, which will set the selection
- */
- public void smoothScrollToPosition(int pos, int duration,
- final OnScrollFinishedListener listener) {
- if (pos >= mAdapter.getCount() || getChildCount() < 1) return;
- int dist = (mSelectedPosition - pos) * (mHorizontal ? getChildHeight(getChildAt(0))
- : getChildWidth(getChildAt(0)));
- ObjectAnimator scroll = ObjectAnimator.ofInt(this, "scrollValue", 0, dist);
- scroll.setDuration(duration);
- scroll.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator animation) {
- mScrollValue = 0;
- listener.onScrollFinished();
- }
- });
- scroll.setInterpolator(new BounceInterpolator());
- scroll.start();
- }
-
- public void setScrollValue(int scroll) {
- trackMotionScroll(scroll - mScrollValue);
- mScrollValue = scroll;
- }
-
- public int getScrollValue() {
- return mScrollValue;
- }
-
- protected void setSelectedPositionInt(int position) {
- mSelectedPosition = position;
- updateSelectedItemMetadata();
- }
-
- void checkSelectionChanged() {
- if (mSelectedPosition != mOldSelectedPosition) {
- selectionChanged();
- mOldSelectedPosition = mSelectedPosition;
- }
- }
-
- private class SelectionNotifier implements Runnable {
- public void run() {
- if (mDataChanged) {
- // Data has changed between when this SelectionNotifier
- // was posted and now. We need to wait until the AdapterView
- // has been synched to the new data.
- if (mAdapter != null) {
- post(this);
- }
- } else {
- fireOnSelected();
- }
- }
- }
-
- void selectionChanged() {
- if (mSuppressSelectionChanged)
- return;
- if (mOnItemSelectedListener != null) {
- if (mInLayout || mBlockLayoutRequests) {
- // If we are in a layout traversal, defer notification
- if (mSelectionNotifier == null) {
- mSelectionNotifier = new SelectionNotifier();
- }
- post(mSelectionNotifier);
- } else {
- fireOnSelected();
- }
- }
-
- // we fire selection events here not in View
- // if (mSelectedPosition != ListView.INVALID_POSITION && isShown() &&
- // !isInTouchMode()) {
- // sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
- // }
- }
-
- private void fireOnSelected() {
- if (mOnItemSelectedListener == null)
- return;
-
- int selection = this.getSelectedItemPosition();
- if (selection >= 0) {
- View v = getSelectedView();
- mOnItemSelectedListener.onItemSelected(this, v, selection,
- mAdapter.getItemId(selection));
- }
- }
-
- public int getSelectedItemPosition() {
- return mSelectedPosition;
- }
-
- public View getSelectedView() {
- if (mItemCount > 0 && mSelectedPosition >= 0) {
- return getChildAt(mSelectedPosition - mFirstPosition);
- } else {
- return null;
- }
- }
-
- private void updateSelectedItemMetadata() {
- View oldSelectedChild = mSelectedChild;
- View child = mSelectedChild = getChildAt(mSelectedPosition
- - mFirstPosition);
- if (child == null) {
- return;
- }
- child.setSelected(true);
- child.setFocusable(true);
-
- if (hasFocus()) {
- child.requestFocus();
- }
- // We unfocus the old child down here so the above hasFocus check
- // returns true
- if (oldSelectedChild != null && oldSelectedChild != child) {
- // Make sure its drawable state doesn't contain 'selected'
- oldSelectedChild.setSelected(false);
- // Make sure it is not focusable anymore, since otherwise arrow keys
- // can make this one be focused
- oldSelectedChild.setFocusable(false);
- }
- }
-
- public void setGravity(int gravity) {
- if (mGravity != gravity) {
- mGravity = gravity;
- requestLayout();
- }
- }
-
- @Override
- protected void onFocusChanged(boolean gainFocus, int direction,
- Rect previouslyFocusedRect) {
- super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
- /*
- * The gallery shows focus by focusing the selected item. So, give focus
- * to our selected item instead. We steal keys from our selected item
- * elsewhere.
- */
- if (gainFocus && mSelectedChild != null) {
- mSelectedChild.requestFocus(direction);
- mSelectedChild.setSelected(true);
- }
- }
-
- void setNextSelectedPositionInt(int position) {
- mSelectedPosition = position;
- }
-
- public int pointToPosition(int x, int y) {
- Rect frame = mTouchFrame;
- if (frame == null) {
- mTouchFrame = new Rect();
- frame = mTouchFrame;
- }
- final int count = getChildCount();
- for (int i = count - 1; i >= 0; i--) {
- View child = getChildAt(i);
- if (child.getVisibility() == View.VISIBLE) {
- child.getHitRect(frame);
- if (frame.contains(x, y)) {
- return mFirstPosition + i;
- }
- }
- }
- return INVALID_POSITION;
- }
-
- private class FlingRunnable implements Runnable {
- private Scroller mScroller;
-
- /**
- * X value reported by mScroller on the previous fling
- */
- private int mLastFlingX;
-
- public FlingRunnable() {
- mScroller = new Scroller(getContext());
- }
-
- private void startCommon() {
- // Remove any pending flings
- removeCallbacks(this);
- }
-
- public void startUsingVelocity(int initialVelocity) {
- if (initialVelocity == 0)
- return;
- startCommon();
- int initialX = initialVelocity < 0 ? Integer.MAX_VALUE : 0;
- mLastFlingX = initialX;
- mScroller.fling(initialX, 0, initialVelocity, 0, 0,
- Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
- post(this);
- }
-
- public void startUsingDistance(int distance) {
- startUsingDistance(distance, mAnimationDuration);
- }
-
- public void startUsingDistance(int distance, int duration) {
- if (distance == 0)
- return;
- startCommon();
- mLastFlingX = 0;
- mScroller.startScroll(0, 0, -distance, 0, duration);
- post(this);
- }
-
- public void stop(boolean scrollIntoSlots) {
- removeCallbacks(this);
- endFling(scrollIntoSlots);
- }
-
- private void endFling(boolean scrollIntoSlots) {
- mScroller.forceFinished(true);
- if (scrollIntoSlots)
- scrollIntoSlots();
- }
-
- public void run() {
- if (mItemCount == 0) {
- endFling(true);
- return;
- }
- mShouldStopFling = false;
- final Scroller scroller = mScroller;
- boolean more = scroller.computeScrollOffset();
- final int x = scroller.getCurrX();
- // Flip sign to convert finger direction to list items direction
- // (e.g. finger moving down means list is moving towards the top)
- int delta = mLastFlingX - x;
- // Pretend that each frame of a fling scroll is a touch scroll
- if (delta > 0) {
- // Moving towards the left. Use first view as mDownTouchPosition
- mDownTouchPosition = mFirstPosition;
- // Don't fling more than 1 screen
- delta = mHorizontal ? Math.min(getWidth() - mPaddingLeft
- - mPaddingRight - 1, delta) : Math.min(getHeight()
- - mPaddingTop - mPaddingBottom - 1, delta);
- } else {
- // Moving towards the right. Use last view as mDownTouchPosition
- int offsetToLast = getChildCount() - 1;
- mDownTouchPosition = mFirstPosition + offsetToLast;
- // Don't fling more than 1 screen
- delta = mHorizontal ? Math.max(-(getWidth() - mPaddingRight
- - mPaddingLeft - 1), delta) : Math.max(-(getHeight()
- - mPaddingBottom - mPaddingTop - 1), delta);
- }
- trackMotionScroll(delta);
- if (more && !mShouldStopFling) {
- mLastFlingX = x;
- post(this);
- } else {
- endFling(true);
- }
- }
- }
-
- /**
- * Gallery extends LayoutParams to provide a place to hold current
- * Transformation information along with previous position/transformation
- * info.
- *
- */
- public static class LayoutParams extends ViewGroup.LayoutParams {
- public LayoutParams(Context c, AttributeSet attrs) {
- super(c, attrs);
- }
-
- public LayoutParams(int w, int h) {
- super(w, h);
- }
-
- public LayoutParams(ViewGroup.LayoutParams source) {
- super(source);
- }
- }
-
- class RecycleBin {
- private final SparseArray<View> mScrapHeap = new SparseArray<View>();
-
- public void put(int position, View v) {
- mScrapHeap.put(position, v);
- }
-
- View get(int position) {
- // System.out.print("Looking for " + position);
- View result = mScrapHeap.get(position);
- if (result != null) {
- // System.out.println(" HIT");
- mScrapHeap.delete(position);
- } else {
- // System.out.println(" MISS");
- }
- return result;
- }
-
- void clear() {
- final SparseArray<View> scrapHeap = mScrapHeap;
- final int count = scrapHeap.size();
- for (int i = 0; i < count; i++) {
- final View view = scrapHeap.valueAt(i);
- if (view != null) {
- removeDetachedView(view, true);
- }
- }
- scrapHeap.clear();
- }
- }
-
-}
diff --git a/src/com/android/browser/view/ScrollerView.java b/src/com/android/browser/view/ScrollerView.java
new file mode 100644
index 0000000..545dd25
--- /dev/null
+++ b/src/com/android/browser/view/ScrollerView.java
@@ -0,0 +1,1869 @@
+/*
+ * 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 com.android.browser.view;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.os.StrictMode;
+import android.util.AttributeSet;
+import android.view.FocusFinder;
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewDebug;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.animation.AnimationUtils;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.OverScroller;
+import android.widget.TextView;
+
+import com.android.internal.R;
+
+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 ScrollView
+ * 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.
+ *
+ * <p>The {@link TextView} class also
+ * takes care of its own scrolling, so does not require a ScrollView, but
+ * using the two together is possible to achieve the effect of a text view
+ * within a larger container.
+ *
+ * <p>ScrollView only supports vertical scrolling.
+ *
+ * @attr ref android.R.styleable#ScrollView_fillViewport
+ */
+public class ScrollerView extends FrameLayout {
+ static final int ANIMATED_SCROLL_GAP = 250;
+
+ static final float MAX_SCROLL_FACTOR = 0.5f;
+
+ private long mLastScroll;
+
+ private final Rect mTempRect = new Rect();
+ protected OverScroller mScroller;
+
+ /**
+ * Position of the last motion event.
+ */
+ private float mLastMotionY;
+
+ /**
+ * 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.
+ */
+ protected View mChildToScrollTo = null;
+
+ /**
+ * True if the user is currently dragging this ScrollView 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).
+ */
+ protected boolean mIsBeingDragged = false;
+
+ /**
+ * Determines speed during touch scrolling
+ */
+ private VelocityTracker mVelocityTracker;
+
+ /**
+ * When set to true, the scroll view measure its child to make it fill the currently
+ * visible area.
+ */
+ @ViewDebug.ExportedProperty(category = "layout")
+ private boolean mFillViewport;
+
+ /**
+ * Whether arrow scrolling is animated.
+ */
+ private boolean mSmoothScrollingEnabled = true;
+
+ private int mTouchSlop;
+ protected int mMinimumVelocity;
+ private int mMaximumVelocity;
+
+ private int mOverscrollDistance;
+ private int mOverflingDistance;
+
+ /**
+ * ID of the active pointer. This is used to retain consistency during
+ * drags/flings if multiple pointers are used.
+ */
+ private int mActivePointerId = INVALID_POINTER;
+
+ /**
+ * The StrictMode "critical time span" objects to catch animation
+ * stutters. Non-null when a time-sensitive animation is
+ * in-flight. Must call finish() on them when done animating.
+ * These are no-ops on user builds.
+ */
+ private StrictMode.Span mScrollStrictSpan = null; // aka "drag"
+ private StrictMode.Span mFlingStrictSpan = null;
+
+ /**
+ * Sentinel value for no current active pointer.
+ * Used by {@link #mActivePointerId}.
+ */
+ private static final int INVALID_POINTER = -1;
+
+ /**
+ * orientation of the scrollview
+ */
+ protected boolean mHorizontal;
+
+ protected boolean mIsOrthoDragged;
+ private float mLastOrthoCoord;
+ private View mDownView;
+ private PointF mDownCoords;
+
+
+ public ScrollerView(Context context) {
+ this(context, null);
+ }
+
+ public ScrollerView(Context context, AttributeSet attrs) {
+ this(context, attrs, com.android.internal.R.attr.scrollViewStyle);
+ }
+
+ public ScrollerView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ initScrollView();
+
+ TypedArray a =
+ context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.ScrollView, defStyle, 0);
+
+ setFillViewport(a.getBoolean(R.styleable.ScrollView_fillViewport, false));
+
+ a.recycle();
+ }
+
+ private void initScrollView() {
+ mScroller = new OverScroller(getContext());
+ setFocusable(true);
+ setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
+ setWillNotDraw(false);
+ final ViewConfiguration configuration = ViewConfiguration.get(mContext);
+ mTouchSlop = configuration.getScaledTouchSlop();
+ mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
+ mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
+ mOverscrollDistance = configuration.getScaledOverscrollDistance();
+ mOverflingDistance = configuration.getScaledOverflingDistance();
+ mDownCoords = new PointF();
+ }
+
+ public void setOrientation(int orientation) {
+ mHorizontal = (orientation == LinearLayout.HORIZONTAL);
+ requestLayout();
+ }
+
+ @Override
+ public boolean shouldDelayChildPressedState() {
+ return true;
+ }
+
+ @Override
+ protected float getTopFadingEdgeStrength() {
+ if (getChildCount() == 0) {
+ return 0.0f;
+ }
+ if (mHorizontal) {
+ final int length = getHorizontalFadingEdgeLength();
+ if (mScrollX < length) {
+ return mScrollX / (float) length;
+ }
+ } else {
+ final int length = getVerticalFadingEdgeLength();
+ if (mScrollY < length) {
+ return mScrollY / (float) length;
+ }
+ }
+ return 1.0f;
+ }
+
+ @Override
+ protected float getBottomFadingEdgeStrength() {
+ if (getChildCount() == 0) {
+ return 0.0f;
+ }
+ if (mHorizontal) {
+ final int length = getHorizontalFadingEdgeLength();
+ final int bottomEdge = getWidth() - mPaddingRight;
+ final int span = getChildAt(0).getRight() - mScrollX - bottomEdge;
+ if (span < length) {
+ return span / (float) length;
+ }
+ } else {
+ final int length = getVerticalFadingEdgeLength();
+ final int bottomEdge = getHeight() - mPaddingBottom;
+ final int span = getChildAt(0).getBottom() - mScrollY - bottomEdge;
+ if (span < length) {
+ return span / (float) length;
+ }
+ }
+ return 1.0f;
+ }
+
+ /**
+ * @return The maximum amount this scroll view will scroll in response to
+ * an arrow event.
+ */
+ public int getMaxScrollAmount() {
+ return (int) (MAX_SCROLL_FACTOR * (mHorizontal
+ ? (mRight - mLeft) : (mBottom - mTop)));
+ }
+
+
+ @Override
+ public void addView(View child) {
+ if (getChildCount() > 0) {
+ throw new IllegalStateException("ScrollView can host only one direct child");
+ }
+
+ super.addView(child);
+ }
+
+ @Override
+ public void addView(View child, int index) {
+ if (getChildCount() > 0) {
+ throw new IllegalStateException("ScrollView 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("ScrollView 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("ScrollView can host only one direct child");
+ }
+
+ super.addView(child, index, params);
+ }
+
+ /**
+ * @return Returns true this ScrollView can be scrolled
+ */
+ private boolean canScroll() {
+ View child = getChildAt(0);
+ if (child != null) {
+ if (mHorizontal) {
+ return getWidth() < child.getWidth() + mPaddingLeft + mPaddingRight;
+ } else {
+ return getHeight() < child.getHeight() + mPaddingTop + mPaddingBottom;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Indicates whether this ScrollView's content is stretched to fill the viewport.
+ *
+ * @return True if the content fills the viewport, false otherwise.
+ *
+ * @attr ref android.R.styleable#ScrollView_fillViewport
+ */
+ public boolean isFillViewport() {
+ return mFillViewport;
+ }
+
+ /**
+ * Indicates this ScrollView whether it should stretch its content height to fill
+ * the viewport or not.
+ *
+ * @param fillViewport True to stretch the content's height to the viewport's
+ * boundaries, false otherwise.
+ *
+ * @attr ref android.R.styleable#ScrollView_fillViewport
+ */
+ public void setFillViewport(boolean fillViewport) {
+ if (fillViewport != mFillViewport) {
+ mFillViewport = fillViewport;
+ requestLayout();
+ }
+ }
+
+ /**
+ * @return Whether arrow scrolling will animate its transition.
+ */
+ public boolean isSmoothScrollingEnabled() {
+ return mSmoothScrollingEnabled;
+ }
+
+ /**
+ * Set whether arrow scrolling will animate its transition.
+ * @param smoothScrollingEnabled whether arrow scrolling will animate its transition
+ */
+ public void setSmoothScrollingEnabled(boolean smoothScrollingEnabled) {
+ mSmoothScrollingEnabled = smoothScrollingEnabled;
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+ if (!mFillViewport) {
+ return;
+ }
+
+ final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+ if (heightMode == MeasureSpec.UNSPECIFIED) {
+ return;
+ }
+
+ if (getChildCount() > 0) {
+ final View child = getChildAt(0);
+ if (mHorizontal) {
+ int width = getMeasuredWidth();
+ if (child.getMeasuredWidth() < width) {
+ final FrameLayout.LayoutParams lp = (LayoutParams) child
+ .getLayoutParams();
+
+ int childHeightMeasureSpec = getChildMeasureSpec(
+ heightMeasureSpec, mPaddingTop + mPaddingBottom,
+ lp.height);
+ width -= mPaddingLeft;
+ width -= mPaddingRight;
+ int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
+ width, MeasureSpec.EXACTLY);
+
+ child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+ }
+ } else {
+ int height = getMeasuredHeight();
+ if (child.getMeasuredHeight() < height) {
+ final FrameLayout.LayoutParams lp = (LayoutParams) child
+ .getLayoutParams();
+
+ int childWidthMeasureSpec = getChildMeasureSpec(
+ widthMeasureSpec, mPaddingLeft + mPaddingRight,
+ lp.width);
+ height -= mPaddingTop;
+ height -= mPaddingBottom;
+ int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
+ height, MeasureSpec.EXACTLY);
+
+ child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ // Let the focused view and/or our descendants get the key first
+ return super.dispatchKeyEvent(event) || 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() && event.getKeyCode() != KeyEvent.KEYCODE_BACK) {
+ 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);
+ } else {
+ handled = fullScroll(View.FOCUS_UP);
+ }
+ break;
+ case KeyEvent.KEYCODE_DPAD_DOWN:
+ if (!event.isAltPressed()) {
+ handled = arrowScroll(View.FOCUS_DOWN);
+ } else {
+ handled = fullScroll(View.FOCUS_DOWN);
+ }
+ break;
+ case KeyEvent.KEYCODE_SPACE:
+ pageScroll(event.isShiftPressed() ? View.FOCUS_UP : View.FOCUS_DOWN);
+ break;
+ }
+ }
+
+ return handled;
+ }
+
+ private boolean inChild(int x, int y) {
+ if (getChildCount() > 0) {
+ final int scrollY = mScrollY;
+ final View child = getChildAt(0);
+ return !(y < child.getTop() - scrollY
+ || y >= child.getBottom() - scrollY
+ || x < child.getLeft()
+ || x >= child.getRight());
+ }
+ return false;
+ }
+
+ private void initOrResetVelocityTracker() {
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ } else {
+ mVelocityTracker.clear();
+ }
+ }
+
+ private void initVelocityTrackerIfNotExists() {
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ }
+ }
+
+ private void recycleVelocityTracker() {
+ if (mVelocityTracker != null) {
+ mVelocityTracker.recycle();
+ mVelocityTracker = null;
+ }
+ }
+
+ @Override
+ public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+ if (disallowIntercept) {
+ recycleVelocityTracker();
+ }
+ super.requestDisallowInterceptTouchEvent(disallowIntercept);
+ }
+
+ @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 ((action == MotionEvent.ACTION_MOVE) && (mIsOrthoDragged)) {
+ return true;
+ }
+ switch (action & MotionEvent.ACTION_MASK) {
+ 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 activePointerId = mActivePointerId;
+ if (activePointerId == INVALID_POINTER) {
+ // If we don't have a valid id, the touch down wasn't on
+ // content.
+ break;
+ }
+
+ final int pointerIndex = ev.findPointerIndex(activePointerId);
+ final float y = mHorizontal ? ev.getX(pointerIndex) : ev
+ .getY(pointerIndex);
+ final int yDiff = (int) Math.abs(y - mLastMotionY);
+ if (yDiff > mTouchSlop) {
+ mIsBeingDragged = true;
+ mLastMotionY = y;
+ initVelocityTrackerIfNotExists();
+ mVelocityTracker.addMovement(ev);
+ if (mScrollStrictSpan == null) {
+ mScrollStrictSpan = StrictMode
+ .enterCriticalSpan("ScrollView-scroll");
+ }
+ } else {
+ final float ocoord = mHorizontal ? ev.getY(pointerIndex) : ev
+ .getX(pointerIndex);
+ if (Math.abs(ocoord - mLastOrthoCoord) > mTouchSlop) {
+ mIsOrthoDragged = true;
+ mLastOrthoCoord = ocoord;
+ initVelocityTrackerIfNotExists();
+ mVelocityTracker.addMovement(ev);
+ }
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_DOWN: {
+ final float y = mHorizontal ? ev.getX() : ev.getY();
+ mDownCoords.x = ev.getX();
+ mDownCoords.y = ev.getY();
+ if (!inChild((int) ev.getX(), (int) ev.getY())) {
+ mIsBeingDragged = false;
+ recycleVelocityTracker();
+ break;
+ }
+
+ /*
+ * Remember location of down touch. ACTION_DOWN always refers to
+ * pointer index 0.
+ */
+ mLastMotionY = y;
+ mActivePointerId = ev.getPointerId(0);
+
+ initOrResetVelocityTracker();
+ mVelocityTracker.addMovement(ev);
+ /*
+ * If being flinged and user touches the screen, initiate drag;
+ * otherwise don't. mScroller.isFinished should be false when being
+ * flinged.
+ */
+ mIsBeingDragged = !mScroller.isFinished();
+ if (mIsBeingDragged && mScrollStrictSpan == null) {
+ mScrollStrictSpan = StrictMode
+ .enterCriticalSpan("ScrollView-scroll");
+ }
+ mIsOrthoDragged = false;
+ final float ocoord = mHorizontal ? ev.getY() : ev.getX();
+ mLastOrthoCoord = ocoord;
+ mDownView = findViewAt((int) ev.getX(), (int) ev.getY());
+ break;
+ }
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ /* Release the drag */
+ mIsBeingDragged = false;
+ mIsOrthoDragged = false;
+ mActivePointerId = INVALID_POINTER;
+ recycleVelocityTracker();
+ if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0,
+ getScrollRange())) {
+ invalidate();
+ }
+ break;
+ case MotionEvent.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ break;
+ }
+
+ /*
+ * The only time we want to intercept motion events is if we are in the
+ * drag mode.
+ */
+ return mIsBeingDragged || mIsOrthoDragged;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ initVelocityTrackerIfNotExists();
+ mVelocityTracker.addMovement(ev);
+
+ final int action = ev.getAction();
+ switch (action & MotionEvent.ACTION_MASK) {
+ case MotionEvent.ACTION_DOWN: {
+ mIsBeingDragged = getChildCount() != 0;
+ if (!mIsBeingDragged) {
+ return false;
+ }
+
+ /*
+ * If being flinged and user touches, stop the fling. isFinished
+ * will be false if being flinged.
+ */
+ if (!mScroller.isFinished()) {
+ mScroller.abortAnimation();
+ if (mFlingStrictSpan != null) {
+ mFlingStrictSpan.finish();
+ mFlingStrictSpan = null;
+ }
+ }
+
+ // Remember where the motion event started
+ mLastMotionY = mHorizontal ? ev.getX() : ev.getY();
+ mActivePointerId = ev.getPointerId(0);
+ break;
+ }
+ case MotionEvent.ACTION_MOVE:
+ if (mIsOrthoDragged) {
+ // Scroll to follow the motion event
+ final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
+ final float x = ev.getX(activePointerIndex);
+ final float y = ev.getY(activePointerIndex);
+ if (isOrthoMove(x - mDownCoords.x, y - mDownCoords.y)) {
+ onOrthoDrag(mDownView, mHorizontal
+ ? y - mDownCoords.y
+ : x - mDownCoords.x);
+ }
+ } else if (mIsBeingDragged) {
+ // Scroll to follow the motion event
+ final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
+ final float y = mHorizontal ? ev.getX(activePointerIndex)
+ : ev.getY(activePointerIndex);
+ final int deltaY = (int) (mLastMotionY - y);
+ mLastMotionY = y;
+
+ final int oldX = mScrollX;
+ final int oldY = mScrollY;
+ final int range = getScrollRange();
+ if (mHorizontal) {
+ if (overScrollBy(deltaY, 0, mScrollX, 0, range, 0,
+ mOverscrollDistance, 0, true)) {
+ // Break our velocity if we hit a scroll barrier.
+ mVelocityTracker.clear();
+ }
+ } else {
+ if (overScrollBy(0, deltaY, 0, mScrollY, 0, range,
+ 0, mOverscrollDistance, true)) {
+ // Break our velocity if we hit a scroll barrier.
+ mVelocityTracker.clear();
+ }
+ }
+ onScrollChanged(mScrollX, mScrollY, oldX, oldY);
+
+ final int overscrollMode = getOverScrollMode();
+ if (overscrollMode == OVER_SCROLL_ALWAYS ||
+ (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0)) {
+ final int pulledToY = mHorizontal ? oldX + deltaY : oldY + deltaY;
+ if (pulledToY < 0) {
+ onPull(pulledToY);
+ } else if (pulledToY > range) {
+ onPull(pulledToY - range);
+ } else {
+ onPull(0);
+ }
+ }
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ final VelocityTracker vtracker = mVelocityTracker;
+ vtracker.computeCurrentVelocity(1000, mMaximumVelocity);
+ if (isOrthoMove(vtracker.getXVelocity(mActivePointerId),
+ vtracker.getYVelocity(mActivePointerId))
+ && mMinimumVelocity < Math.abs((mHorizontal ? vtracker.getYVelocity()
+ : vtracker.getXVelocity()))) {
+ onOrthoFling(mDownView, mHorizontal ? vtracker.getYVelocity()
+ : vtracker.getXVelocity());
+ break;
+ }
+ if (mIsOrthoDragged) {
+ onOrthoDragFinished(mDownView);
+ mActivePointerId = INVALID_POINTER;
+ endDrag();
+ } else if (mIsBeingDragged) {
+ final VelocityTracker velocityTracker = mVelocityTracker;
+ velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
+ int initialVelocity = mHorizontal
+ ? (int) velocityTracker.getXVelocity(mActivePointerId)
+ : (int) velocityTracker.getYVelocity(mActivePointerId);
+
+ if (getChildCount() > 0) {
+ if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
+ fling(-initialVelocity);
+ } else {
+ final int bottom = getScrollRange();
+ if (mHorizontal) {
+ if (mScroller.springBack(mScrollX, mScrollY, 0, bottom, 0, 0)) {
+ invalidate();
+ }
+ } else {
+ if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, bottom)) {
+ invalidate();
+ }
+ }
+ }
+ onPull(0);
+ }
+
+ mActivePointerId = INVALID_POINTER;
+ endDrag();
+ }
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ if (mIsOrthoDragged) {
+ onOrthoDragFinished(mDownView);
+ mActivePointerId = INVALID_POINTER;
+ endDrag();
+ } else if (mIsBeingDragged && getChildCount() > 0) {
+ if (mHorizontal) {
+ if (mScroller.springBack(mScrollX, mScrollY, 0, getScrollRange(), 0, 0)) {
+ invalidate();
+ }
+ } else {
+ if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, getScrollRange())) {
+ invalidate();
+ }
+ }
+ mActivePointerId = INVALID_POINTER;
+ endDrag();
+ }
+ break;
+ case MotionEvent.ACTION_POINTER_DOWN: {
+ final int index = ev.getActionIndex();
+ final float y = mHorizontal ? ev.getX(index) : ev.getY(index);
+ mLastMotionY = y;
+ mLastOrthoCoord = mHorizontal ? ev.getY(index) : ev.getX(index);
+ mActivePointerId = ev.getPointerId(index);
+ break;
+ }
+ case MotionEvent.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ mLastMotionY = mHorizontal
+ ? ev.getX(ev.findPointerIndex(mActivePointerId))
+ : ev.getY(ev.findPointerIndex(mActivePointerId));
+ break;
+ }
+ return true;
+ }
+
+ protected View findViewAt(int x, int y) {
+ // subclass responsibility
+ return null;
+ }
+
+ protected void onPull(int delta) {
+ }
+
+ private void onSecondaryPointerUp(MotionEvent ev) {
+ final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
+ MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+ final int pointerId = ev.getPointerId(pointerIndex);
+ if (pointerId == mActivePointerId) {
+ // This was our active pointer going up. Choose a new
+ // active pointer and adjust accordingly.
+ // TODO: Make this decision more intelligent.
+ final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+ mLastMotionY = mHorizontal ? ev.getX(newPointerIndex) : ev.getY(newPointerIndex);
+ mActivePointerId = ev.getPointerId(newPointerIndex);
+ if (mVelocityTracker != null) {
+ mVelocityTracker.clear();
+ }
+ mLastOrthoCoord = mHorizontal ? ev.getY(newPointerIndex)
+ : ev.getX(newPointerIndex);
+ }
+ }
+
+ @Override
+ public boolean onGenericMotionEvent(MotionEvent event) {
+ if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_SCROLL: {
+ if (!mIsBeingDragged) {
+ if (mHorizontal) {
+ final float hscroll = event
+ .getAxisValue(MotionEvent.AXIS_HSCROLL);
+ if (hscroll != 0) {
+ final int delta = (int) (hscroll * getHorizontalScrollFactor());
+ final int range = getScrollRange();
+ int oldScrollX = mScrollX;
+ int newScrollX = oldScrollX - delta;
+ if (newScrollX < 0) {
+ newScrollX = 0;
+ } else if (newScrollX > range) {
+ newScrollX = range;
+ }
+ if (newScrollX != oldScrollX) {
+ super.scrollTo(newScrollX, mScrollY);
+ return true;
+ }
+ }
+ } else {
+ final float vscroll = event
+ .getAxisValue(MotionEvent.AXIS_VSCROLL);
+ if (vscroll != 0) {
+ final int delta = (int) (vscroll * getVerticalScrollFactor());
+ final int range = getScrollRange();
+ int oldScrollY = mScrollY;
+ int newScrollY = oldScrollY - delta;
+ if (newScrollY < 0) {
+ newScrollY = 0;
+ } else if (newScrollY > range) {
+ newScrollY = range;
+ }
+ if (newScrollY != oldScrollY) {
+ super.scrollTo(mScrollX, newScrollY);
+ return true;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return super.onGenericMotionEvent(event);
+ }
+
+ protected void onOrthoDrag(View draggedView, float distance) {
+ }
+
+ protected void onOrthoDragFinished(View draggedView) {
+ }
+
+ protected void onOrthoFling(View draggedView, float velocity) {
+ }
+
+ @Override
+ protected void onOverScrolled(int scrollX, int scrollY,
+ boolean clampedX, boolean clampedY) {
+ // Treat animating scrolls differently; see #computeScroll() for why.
+ if (!mScroller.isFinished()) {
+ mScrollX = scrollX;
+ mScrollY = scrollY;
+ invalidateParentIfNeeded();
+ if (mHorizontal && clampedX) {
+ mScroller.springBack(mScrollX, mScrollY, 0, getScrollRange(), 0, 0);
+ } else if (!mHorizontal && clampedY) {
+ mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, getScrollRange());
+ }
+ } else {
+ super.scrollTo(scrollX, scrollY);
+ }
+ awakenScrollBars();
+ }
+
+ @Override
+ public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+ super.onInitializeAccessibilityNodeInfo(info);
+ info.setScrollable(true);
+ }
+
+ @Override
+ public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+ super.onInitializeAccessibilityEvent(event);
+ event.setScrollable(true);
+ }
+
+ @Override
+ public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+ // Do not append text content to scroll events they are fired frequently
+ // and the client has already received another event type with the text.
+ if (event.getEventType() != AccessibilityEvent.TYPE_VIEW_SCROLLED) {
+ super.dispatchPopulateAccessibilityEvent(event);
+ }
+ return false;
+ }
+
+ private int getScrollRange() {
+ int scrollRange = 0;
+ if (getChildCount() > 0) {
+ View child = getChildAt(0);
+ if (mHorizontal) {
+ scrollRange = Math.max(0,
+ child.getWidth() - (getWidth() - mPaddingRight - mPaddingLeft));
+ } else {
+ scrollRange = Math.max(0,
+ child.getHeight() - (getHeight() - mPaddingBottom - mPaddingTop));
+ }
+ }
+ return scrollRange;
+ }
+
+ /**
+ * <p>
+ * 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.
+ * </p>
+ *
+ * @param topFocus look for a candidate 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, 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 fadingEdgeLength = (mHorizontal
+ ? getHorizontalFadingEdgeLength()
+ : getVerticalFadingEdgeLength()) / 2;
+ final int topWithoutFadingEdge = top + fadingEdgeLength;
+ final int bottomWithoutFadingEdge = top + (mHorizontal ? getWidth() : getHeight()) - fadingEdgeLength;
+
+ if ((preferredFocusable != null)
+ && ((mHorizontal ? preferredFocusable.getLeft() : preferredFocusable.getTop())
+ < bottomWithoutFadingEdge)
+ && ((mHorizontal ? preferredFocusable.getRight() : preferredFocusable.getBottom()) > topWithoutFadingEdge)) {
+ return preferredFocusable;
+ }
+
+ return findFocusableViewInBounds(topFocus, topWithoutFadingEdge,
+ bottomWithoutFadingEdge);
+ }
+
+ /**
+ * <p>
+ * Finds the next focusable component that fits in the specified bounds.
+ * </p>
+ *
+ * @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) {
+
+ 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 = mHorizontal ? view.getLeft() : view.getTop();
+ int viewBottom = mHorizontal ? view.getRight() : view.getBottom();
+
+ if (top < viewBottom && viewTop < bottom) {
+ /*
+ * the focusable is in the target area, it is a candidate for
+ * focusing
+ */
+
+ final boolean viewIsFullyContained = (top < viewTop) &&
+ (viewBottom < bottom);
+
+ if (focusCandidate == null) {
+ /* No candidate, take this one */
+ focusCandidate = view;
+ foundFullyContainedFocusable = viewIsFullyContained;
+ } else {
+ final int ctop = mHorizontal ? focusCandidate.getLeft() : focusCandidate.getTop();
+ final int cbot = mHorizontal ? focusCandidate.getRight() : focusCandidate.getBottom();
+ final boolean viewIsCloserToBoundary =
+ (topFocus && viewTop < ctop) ||
+ (!topFocus && viewBottom > cbot);
+
+ if (foundFullyContainedFocusable) {
+ if (viewIsFullyContained && viewIsCloserToBoundary) {
+ /*
+ * 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 (viewIsCloserToBoundary) {
+ /*
+ * Partially contained view beats another partially
+ * contained view if it's closer
+ */
+ focusCandidate = view;
+ }
+ }
+ }
+ }
+ }
+
+ return focusCandidate;
+ }
+
+ // i was here
+
+ /**
+ * <p>Handles scrolling in response to a "page up/down" shortcut press. This
+ * method will scroll the view by one page up or down 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.</p>
+ *
+ * @param direction the scroll direction: {@link android.view.View#FOCUS_UP}
+ * to go one page up or
+ * {@link android.view.View#FOCUS_DOWN} to go one page down
+ * @return true if the key event is consumed by this method, false otherwise
+ */
+ public boolean pageScroll(int direction) {
+ boolean down = direction == View.FOCUS_DOWN;
+ int height = getHeight();
+
+ if (down) {
+ mTempRect.top = getScrollY() + height;
+ int count = getChildCount();
+ if (count > 0) {
+ View view = getChildAt(count - 1);
+ if (mTempRect.top + height > view.getBottom()) {
+ mTempRect.top = view.getBottom() - height;
+ }
+ }
+ } else {
+ mTempRect.top = getScrollY() - height;
+ if (mTempRect.top < 0) {
+ mTempRect.top = 0;
+ }
+ }
+ mTempRect.bottom = mTempRect.top + height;
+
+ return scrollAndFocus(direction, mTempRect.top, mTempRect.bottom);
+ }
+
+ /**
+ * <p>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.</p>
+ *
+ * @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 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() + mPaddingBottom;
+ mTempRect.top = mTempRect.bottom - height;
+ }
+ }
+
+ return scrollAndFocus(direction, mTempRect.top, mTempRect.bottom);
+ }
+
+ /**
+ * <p>Scrolls the view to make the area defined by <code>top</code> and
+ * <code>bottom</code> 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.</p>
+ *
+ * @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 direction, int top, int bottom) {
+ boolean handled = true;
+
+ int height = getHeight();
+ int containerTop = getScrollY();
+ int containerBottom = containerTop + height;
+ boolean up = direction == View.FOCUS_UP;
+
+ View newFocused = findFocusableViewInBounds(up, top, bottom);
+ if (newFocused == null) {
+ newFocused = this;
+ }
+
+ if (top >= containerTop && bottom <= containerBottom) {
+ handled = false;
+ } else {
+ int delta = up ? (top - containerTop) : (bottom - containerBottom);
+ doScrollY(delta);
+ }
+
+ if (newFocused != findFocus()) newFocused.requestFocus(direction);
+
+ 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) {
+
+ View currentFocused = findFocus();
+ if (currentFocused == this) currentFocused = null;
+
+ View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+
+ final int maxJump = getMaxScrollAmount();
+
+ if (nextFocused != null && isWithinDeltaOfScreen(nextFocused, maxJump, getHeight())) {
+ nextFocused.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(nextFocused, mTempRect);
+ int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+ doScrollY(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() - mPaddingBottom;
+ if (daBottom - screenBottom < maxJump) {
+ scrollDelta = daBottom - screenBottom;
+ }
+ }
+ }
+ if (scrollDelta == 0) {
+ return false;
+ }
+ doScrollY(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta);
+ }
+
+ if (currentFocused != null && currentFocused.isFocused()
+ && isOffScreen(currentFocused)) {
+ // previously focused item still has focus and is off screen, give
+ // it up (take it back to ourselves)
+ // (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we are
+ // sure to
+ // get it)
+ final int descendantFocusability = getDescendantFocusability(); // save
+ setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
+ requestFocus();
+ setDescendantFocusability(descendantFocusability); // restore
+ }
+ return true;
+ }
+
+ private boolean isOrthoMove(float moveX, float moveY) {
+ return mHorizontal && Math.abs(moveY) > Math.abs(moveX)
+ || !mHorizontal && Math.abs(moveX) > Math.abs(moveY);
+ }
+
+ /**
+ * @return whether the descendant of this scroll view is scrolled off
+ * screen.
+ */
+ private boolean isOffScreen(View descendant) {
+ if (mHorizontal) {
+ return !isWithinDeltaOfScreen(descendant, getWidth(), 0);
+ } else {
+ return !isWithinDeltaOfScreen(descendant, 0, getHeight());
+ }
+ }
+
+ /**
+ * @return whether the descendant of this scroll view is within delta
+ * pixels of being on the screen.
+ */
+ private boolean isWithinDeltaOfScreen(View descendant, int delta, int height) {
+ descendant.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(descendant, mTempRect);
+ if (mHorizontal) {
+ return (mTempRect.right + delta) >= getScrollX()
+ && (mTempRect.left - delta) <= (getScrollX() + height);
+ } else {
+ return (mTempRect.bottom + delta) >= getScrollY()
+ && (mTempRect.top - delta) <= (getScrollY() + height);
+ }
+ }
+
+ /**
+ * Smooth scroll by a Y delta
+ *
+ * @param delta the number of pixels to scroll by on the Y axis
+ */
+ private void doScrollY(int delta) {
+ if (delta != 0) {
+ if (mSmoothScrollingEnabled) {
+ if (mHorizontal) {
+ smoothScrollBy(0, delta);
+ } else {
+ smoothScrollBy(delta, 0);
+ }
+ } else {
+ if (mHorizontal) {
+ scrollBy(0, delta);
+ } else {
+ scrollBy(delta, 0);
+ }
+ }
+ }
+ }
+
+ /**
+ * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
+ *
+ * @param dx the number of pixels to scroll by on the X axis
+ * @param dy the number of pixels to scroll by on the Y axis
+ */
+ public final void smoothScrollBy(int dx, int dy) {
+ if (getChildCount() == 0) {
+ // Nothing to do.
+ return;
+ }
+ long duration = AnimationUtils.currentAnimationTimeMillis() - mLastScroll;
+ if (duration > ANIMATED_SCROLL_GAP) {
+ if (mHorizontal) {
+ final int width = getWidth() - mPaddingRight - mPaddingLeft;
+ final int right = getChildAt(0).getWidth();
+ final int maxX = Math.max(0, right - width);
+ final int scrollX = mScrollX;
+ dx = Math.max(0, Math.min(scrollX + dx, maxX)) - scrollX;
+ mScroller.startScroll(scrollX, mScrollY, dx, 0);
+ } else {
+ final int height = getHeight() - mPaddingBottom - mPaddingTop;
+ final int bottom = getChildAt(0).getHeight();
+ final int maxY = Math.max(0, bottom - height);
+ final int scrollY = mScrollY;
+ dy = Math.max(0, Math.min(scrollY + dy, maxY)) - scrollY;
+ mScroller.startScroll(mScrollX, scrollY, 0, dy);
+ }
+ invalidate();
+ } else {
+ if (!mScroller.isFinished()) {
+ mScroller.abortAnimation();
+ if (mFlingStrictSpan != null) {
+ mFlingStrictSpan.finish();
+ mFlingStrictSpan = null;
+ }
+ }
+ scrollBy(dx, dy);
+ }
+ mLastScroll = AnimationUtils.currentAnimationTimeMillis();
+ }
+
+ /**
+ * Like {@link #scrollTo}, but scroll smoothly instead of immediately.
+ *
+ * @param x the position where to scroll on the X axis
+ * @param y the position where to scroll on the Y axis
+ */
+ public final void smoothScrollTo(int x, int y) {
+ smoothScrollBy(x - mScrollX, y - mScrollY);
+ }
+
+ /**
+ * <p>
+ * The scroll range of a scroll view is the overall height of all of its
+ * children.
+ * </p>
+ */
+ @Override
+ protected int computeVerticalScrollRange() {
+ if (mHorizontal) {
+ return super.computeVerticalScrollRange();
+ }
+ final int count = getChildCount();
+ final int contentHeight = getHeight() - mPaddingBottom - mPaddingTop;
+ if (count == 0) {
+ return contentHeight;
+ }
+
+ int scrollRange = getChildAt(0).getBottom();
+ final int scrollY = mScrollY;
+ final int overscrollBottom = Math.max(0, scrollRange - contentHeight);
+ if (scrollY < 0) {
+ scrollRange -= scrollY;
+ } else if (scrollY > overscrollBottom) {
+ scrollRange += scrollY - overscrollBottom;
+ }
+
+ return scrollRange;
+ }
+
+ /**
+ * <p>
+ * The scroll range of a scroll view is the overall height of all of its
+ * children.
+ * </p>
+ */
+ @Override
+ protected int computeHorizontalScrollRange() {
+ if (!mHorizontal) {
+ return super.computeHorizontalScrollRange();
+ }
+ final int count = getChildCount();
+ final int contentWidth = getWidth() - mPaddingRight - mPaddingLeft;
+ if (count == 0) {
+ return contentWidth;
+ }
+
+ int scrollRange = getChildAt(0).getRight();
+ final int scrollX = mScrollX;
+ final int overscrollBottom = Math.max(0, scrollRange - contentWidth);
+ if (scrollX < 0) {
+ scrollRange -= scrollX;
+ } else if (scrollX > overscrollBottom) {
+ scrollRange += scrollX - overscrollBottom;
+ }
+
+ return scrollRange;
+ }
+
+ @Override
+ protected int computeVerticalScrollOffset() {
+ return Math.max(0, super.computeVerticalScrollOffset());
+ }
+
+ @Override
+ protected int computeHorizontalScrollOffset() {
+ return Math.max(0, super.computeHorizontalScrollOffset());
+ }
+
+ @Override
+ protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec) {
+ ViewGroup.LayoutParams lp = child.getLayoutParams();
+
+ int childWidthMeasureSpec;
+ int childHeightMeasureSpec;
+
+ if (mHorizontal) {
+ childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ + mPaddingBottom, lp.height);
+
+ childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+ } else {
+ childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft
+ + mPaddingRight, lp.width);
+
+ childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+ }
+
+ child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+ }
+
+ @Override
+ protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
+ int parentHeightMeasureSpec, int heightUsed) {
+ final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
+
+ int childWidthMeasureSpec;
+ int childHeightMeasureSpec;
+ if (mHorizontal) {
+ childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
+ mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
+ + heightUsed, lp.height);
+ childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
+ lp.leftMargin + lp.rightMargin, MeasureSpec.UNSPECIFIED);
+ } else {
+ childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
+ mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
+ + widthUsed, lp.width);
+ childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
+ lp.topMargin + lp.bottomMargin, MeasureSpec.UNSPECIFIED);
+ }
+ child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+ }
+
+ @Override
+ public void computeScroll() {
+ if (mScroller.computeScrollOffset()) {
+ // This is called at drawing time by ViewGroup. We don't want to
+ // re-show the scrollbars at this point, which scrollTo will do,
+ // so we replicate most of scrollTo here.
+ //
+ // It's a little odd to call onScrollChanged from inside the drawing.
+ //
+ // It is, except when you remember that computeScroll() is used to
+ // animate scrolling. So unless we want to defer the onScrollChanged()
+ // until the end of the animated scrolling, we don't really have a
+ // choice here.
+ //
+ // I agree. The alternative, which I think would be worse, is to post
+ // something and tell the subclasses later. This is bad because there
+ // will be a window where mScrollX/Y is different from what the app
+ // thinks it is.
+ //
+ int oldX = mScrollX;
+ int oldY = mScrollY;
+ int x = mScroller.getCurrX();
+ int y = mScroller.getCurrY();
+
+ if (oldX != x || oldY != y) {
+ if (mHorizontal) {
+ overScrollBy(x - oldX, y - oldY, oldX, oldY, getScrollRange(), 0,
+ mOverflingDistance, 0, false);
+ } else {
+ overScrollBy(x - oldX, y - oldY, oldX, oldY, 0, getScrollRange(),
+ 0, mOverflingDistance, false);
+ }
+ onScrollChanged(mScrollX, mScrollY, oldX, oldY);
+ }
+ awakenScrollBars();
+
+ // Keep on drawing until the animation has finished.
+ postInvalidate();
+ } else {
+ if (mFlingStrictSpan != null) {
+ mFlingStrictSpan.finish();
+ mFlingStrictSpan = null;
+ }
+ }
+ }
+
+ /**
+ * Scrolls the view to the given child.
+ *
+ * @param child the View to scroll to
+ */
+ private void scrollToChild(View child) {
+ child.getDrawingRect(mTempRect);
+
+ /* Offset from child's local coordinates to ScrollView coordinates */
+ offsetDescendantRectToMyCoords(child, mTempRect);
+ scrollToChildRect(mTempRect, true);
+ }
+
+ /**
+ * If rect is off screen, scroll just enough to get it (or at least the
+ * first screen size chunk of it) on screen.
+ *
+ * @param rect The rectangle.
+ * @param immediate True to scroll immediately without animation
+ * @return true if scrolling was performed
+ */
+ private boolean scrollToChildRect(Rect rect, boolean immediate) {
+ final int delta = computeScrollDeltaToGetChildRectOnScreen(rect);
+ final boolean scroll = delta != 0;
+ if (scroll) {
+ if (immediate) {
+ if (mHorizontal) {
+ scrollBy(delta, 0);
+ } else {
+ scrollBy(0, delta);
+ }
+ } else {
+ if (mHorizontal) {
+ smoothScrollBy(delta, 0);
+ } else {
+ smoothScrollBy(0, delta);
+ }
+ }
+ }
+ return scroll;
+ }
+
+ /**
+ * Compute the amount to scroll in the Y direction in order to get
+ * a rectangle completely on the screen (or, if taller than the screen,
+ * at least the first screen size chunk of it).
+ *
+ * @param rect The rect.
+ * @return The scroll delta.
+ */
+ protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
+ if (mHorizontal) {
+ return computeScrollDeltaToGetChildRectOnScreenHorizontal(rect);
+ } else {
+ return computeScrollDeltaToGetChildRectOnScreenVertical(rect);
+ }
+ }
+
+ private int computeScrollDeltaToGetChildRectOnScreenVertical(Rect rect) {
+ if (getChildCount() == 0) return 0;
+
+ int height = getHeight();
+ int screenTop = getScrollY();
+ int screenBottom = screenTop + height;
+
+ int fadingEdge = getVerticalFadingEdgeLength();
+
+ // leave room for top fading edge as long as rect isn't at very top
+ if (rect.top > 0) {
+ screenTop += fadingEdge;
+ }
+
+ // leave room for bottom fading edge as long as rect isn't at very bottom
+ if (rect.bottom < getChildAt(0).getHeight()) {
+ screenBottom -= fadingEdge;
+ }
+
+ int scrollYDelta = 0;
+
+ if (rect.bottom > screenBottom && rect.top > screenTop) {
+ // need to move down to get it in view: move down just enough so
+ // that the entire rectangle is in view (or at least the first
+ // screen size chunk).
+
+ if (rect.height() > height) {
+ // just enough to get screen size chunk on
+ scrollYDelta += (rect.top - screenTop);
+ } else {
+ // get entire rect at bottom of screen
+ scrollYDelta += (rect.bottom - screenBottom);
+ }
+
+ // make sure we aren't scrolling beyond the end of our content
+ int bottom = getChildAt(0).getBottom();
+ int distanceToBottom = bottom - screenBottom;
+ scrollYDelta = Math.min(scrollYDelta, distanceToBottom);
+
+ } else if (rect.top < screenTop && rect.bottom < screenBottom) {
+ // need to move up to get it in view: move up just enough so that
+ // entire rectangle is in view (or at least the first screen
+ // size chunk of it).
+
+ if (rect.height() > height) {
+ // screen size chunk
+ scrollYDelta -= (screenBottom - rect.bottom);
+ } else {
+ // entire rect at top
+ scrollYDelta -= (screenTop - rect.top);
+ }
+
+ // make sure we aren't scrolling any further than the top our content
+ scrollYDelta = Math.max(scrollYDelta, -getScrollY());
+ }
+ return scrollYDelta;
+ }
+
+ private int computeScrollDeltaToGetChildRectOnScreenHorizontal(Rect rect) {
+ if (getChildCount() == 0) return 0;
+
+ int width = getWidth();
+ int screenLeft = getScrollX();
+ int screenRight = screenLeft + width;
+
+ int fadingEdge = getHorizontalFadingEdgeLength();
+
+ // leave room for left fading edge as long as rect isn't at very left
+ if (rect.left > 0) {
+ screenLeft += fadingEdge;
+ }
+
+ // leave room for right fading edge as long as rect isn't at very right
+ if (rect.right < getChildAt(0).getWidth()) {
+ screenRight -= fadingEdge;
+ }
+
+ int scrollXDelta = 0;
+
+ if (rect.right > screenRight && rect.left > screenLeft) {
+ // need to move right to get it in view: move right just enough so
+ // that the entire rectangle is in view (or at least the first
+ // screen size chunk).
+
+ if (rect.width() > width) {
+ // just enough to get screen size chunk on
+ scrollXDelta += (rect.left - screenLeft);
+ } else {
+ // get entire rect at right of screen
+ scrollXDelta += (rect.right - screenRight);
+ }
+
+ // make sure we aren't scrolling beyond the end of our content
+ int right = getChildAt(0).getRight();
+ int distanceToRight = right - screenRight;
+ scrollXDelta = Math.min(scrollXDelta, distanceToRight);
+
+ } else if (rect.left < screenLeft && rect.right < screenRight) {
+ // need to move right to get it in view: move right just enough so that
+ // entire rectangle is in view (or at least the first screen
+ // size chunk of it).
+
+ if (rect.width() > width) {
+ // screen size chunk
+ scrollXDelta -= (screenRight - rect.right);
+ } else {
+ // entire rect at left
+ scrollXDelta -= (screenLeft - rect.left);
+ }
+
+ // make sure we aren't scrolling any further than the left our content
+ scrollXDelta = Math.max(scrollXDelta, -getScrollX());
+ }
+ return scrollXDelta;
+ }
+
+
+ @Override
+ public void requestChildFocus(View child, View focused) {
+ if (!mIsLayoutDirty) {
+ scrollToChild(focused);
+ } else {
+ // The child may not be laid out yet, we can't compute the scroll yet
+ mChildToScrollTo = focused;
+ }
+ super.requestChildFocus(child, focused);
+ }
+
+
+ /**
+ * When looking for focus in children of a scroll view, need to be a little
+ * more careful not to give focus to something that is scrolled off screen.
+ *
+ * This is more expensive than the default {@link android.view.ViewGroup}
+ * implementation, otherwise this behavior might have been made the default.
+ */
+ @Override
+ protected boolean onRequestFocusInDescendants(int direction,
+ Rect previouslyFocusedRect) {
+
+ // convert from forward / backward notation to up / down / left / right
+ // (ugh).
+ if (mHorizontal) {
+ if (direction == View.FOCUS_FORWARD) {
+ direction = View.FOCUS_RIGHT;
+ } else if (direction == View.FOCUS_BACKWARD) {
+ direction = View.FOCUS_LEFT;
+ }
+ } else {
+ if (direction == View.FOCUS_FORWARD) {
+ direction = View.FOCUS_DOWN;
+ } else if (direction == View.FOCUS_BACKWARD) {
+ direction = View.FOCUS_UP;
+ }
+ }
+
+ final View nextFocus = previouslyFocusedRect == null ?
+ FocusFinder.getInstance().findNextFocus(this, null, direction) :
+ FocusFinder.getInstance().findNextFocusFromRect(this,
+ previouslyFocusedRect, direction);
+
+ if (nextFocus == null) {
+ return false;
+ }
+
+ if (isOffScreen(nextFocus)) {
+ return false;
+ }
+
+ return nextFocus.requestFocus(direction, previouslyFocusedRect);
+ }
+
+ @Override
+ public boolean requestChildRectangleOnScreen(View child, Rect rectangle,
+ boolean immediate) {
+ // offset into coordinate space of this scroll view
+ rectangle.offset(child.getLeft() - child.getScrollX(),
+ child.getTop() - child.getScrollY());
+
+ return scrollToChildRect(rectangle, immediate);
+ }
+
+ @Override
+ public void requestLayout() {
+ mIsLayoutDirty = true;
+ super.requestLayout();
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+
+ if (mScrollStrictSpan != null) {
+ mScrollStrictSpan.finish();
+ mScrollStrictSpan = null;
+ }
+ if (mFlingStrictSpan != null) {
+ mFlingStrictSpan.finish();
+ mFlingStrictSpan = null;
+ }
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int l, int t, int r, int b) {
+ super.onLayout(changed, l, t, r, b);
+ mIsLayoutDirty = false;
+ // Give a child focus if it needs it
+ if (mChildToScrollTo != null && isViewDescendantOf(mChildToScrollTo, this)) {
+ scrollToChild(mChildToScrollTo);
+ }
+ mChildToScrollTo = null;
+
+ // Calling this with the present values causes it to re-clam them
+ scrollTo(mScrollX, mScrollY);
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+
+ View currentFocused = findFocus();
+ if (null == currentFocused || this == currentFocused)
+ return;
+
+ // If the currently-focused view was visible on the screen when the
+ // screen was at the old height, then scroll the screen to make that
+ // view visible with the new screen height.
+ if (isWithinDeltaOfScreen(currentFocused, 0, oldh)) {
+ currentFocused.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(currentFocused, mTempRect);
+ int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+ doScrollY(scrollDelta);
+ }
+ }
+
+ /**
+ * Return true if child is an descendant of parent, (or equal to the parent).
+ */
+ private boolean isViewDescendantOf(View child, View parent) {
+ if (child == parent) {
+ return true;
+ }
+
+ final ViewParent theParent = child.getParent();
+ return (theParent instanceof ViewGroup) && isViewDescendantOf((View) theParent, parent);
+ }
+
+ /**
+ * Fling the scroll view
+ *
+ * @param velocityY The initial velocity in the Y direction. Positive
+ * numbers mean that the finger/cursor is moving down the screen,
+ * which means we want to scroll towards the top.
+ */
+ public void fling(int velocityY) {
+ if (getChildCount() > 0) {
+ if (mHorizontal) {
+ int width = getWidth() - mPaddingRight - mPaddingLeft;
+ int right = getChildAt(0).getWidth();
+
+ mScroller.fling(mScrollX, mScrollY, velocityY, 0,
+ 0, Math.max(0, right - width), 0, 0, width/2, 0);
+ } else {
+ int height = getHeight() - mPaddingBottom - mPaddingTop;
+ int bottom = getChildAt(0).getHeight();
+
+ mScroller.fling(mScrollX, mScrollY, 0, velocityY, 0, 0, 0,
+ Math.max(0, bottom - height), 0, height/2);
+ }
+ if (mFlingStrictSpan == null) {
+ mFlingStrictSpan = StrictMode.enterCriticalSpan("ScrollView-fling");
+ }
+
+ invalidate();
+ }
+ }
+
+ private void endDrag() {
+ mIsBeingDragged = false;
+ mIsOrthoDragged = false;
+ mDownView = null;
+ recycleVelocityTracker();
+ if (mScrollStrictSpan != null) {
+ mScrollStrictSpan.finish();
+ mScrollStrictSpan = null;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>This version also clamps the scrolling to the bounds of our child.
+ */
+ @Override
+ public void scrollTo(int x, int y) {
+ // we rely on the fact the View.scrollBy calls scrollTo.
+ if (getChildCount() > 0) {
+ View child = getChildAt(0);
+ x = clamp(x, getWidth() - mPaddingRight - mPaddingLeft, child.getWidth());
+ y = clamp(y, getHeight() - mPaddingBottom - mPaddingTop, child.getHeight());
+ if (x != mScrollX || y != mScrollY) {
+ super.scrollTo(x, y);
+ }
+ }
+ }
+
+ private int clamp(int n, int my, int child) {
+ if (my >= child || n < 0) {
+ /* my >= child is this case:
+ * |--------------- me ---------------|
+ * |------ child ------|
+ * or
+ * |--------------- me ---------------|
+ * |------ child ------|
+ * or
+ * |--------------- me ---------------|
+ * |------ child ------|
+ *
+ * n < 0 is this case:
+ * |------ me ------|
+ * |-------- child --------|
+ * |-- mScrollX --|
+ */
+ return 0;
+ }
+ if ((my+n) > child) {
+ /* this case:
+ * |------ me ------|
+ * |------ child ------|
+ * |-- mScrollX --|
+ */
+ return child-my;
+ }
+ return n;
+ }
+
+}