new iteration of the navigation UI
use live webviews
Change-Id: Ie787c76470e445548d358374f83f33a1b0b0b5cf
diff --git a/src/com/android/browser/BaseUi.java b/src/com/android/browser/BaseUi.java
index 7530732..e2fea16 100644
--- a/src/com/android/browser/BaseUi.java
+++ b/src/com/android/browser/BaseUi.java
@@ -207,6 +207,11 @@
return false;
}
+ @Override
+ public boolean onMenuKey() {
+ return false;
+ }
+
// Tab callbacks
@Override
public void onTabDataChanged(Tab tab) {
diff --git a/src/com/android/browser/BrowserWebView.java b/src/com/android/browser/BrowserWebView.java
index a1d8c2d..6cdc063 100644
--- a/src/com/android/browser/BrowserWebView.java
+++ b/src/com/android/browser/BrowserWebView.java
@@ -22,6 +22,7 @@
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
+import android.view.ViewConfiguration;
import android.webkit.WebView;
import java.util.Map;
@@ -38,6 +39,10 @@
private TitleBarBase mTitleBar;
private int mCaptureSize;
private Bitmap mCapture;
+ private boolean mNavMode;
+ private boolean mTracking;
+ private int mSlop;
+ float mDownX, mDownY;
/**
* @param context
@@ -79,11 +84,17 @@
}
private void init() {
+ mNavMode = false;
+ mSlop = ViewConfiguration.get(mContext).getScaledTouchSlop();
mCaptureSize = mContext.getResources().getDimensionPixelSize(R.dimen.tab_capture_size);
mCapture = Bitmap.createBitmap(mCaptureSize, mCaptureSize,
Bitmap.Config.RGB_565);
}
+ protected void setNavMode(boolean enabled) {
+ mNavMode = enabled;
+ }
+
@Override
protected int getTitleHeight() {
return (mTitleBar != null) ? mTitleBar.getEmbeddedHeight() : 0;
@@ -116,13 +127,36 @@
@Override
public boolean onTouchEvent(MotionEvent evt) {
- if (MotionEvent.ACTION_DOWN == evt.getActionMasked()) {
- mUserInitiated = true;
- } else if (MotionEvent.ACTION_UP == evt.getActionMasked()
- || (MotionEvent.ACTION_CANCEL == evt.getActionMasked())) {
- mUserInitiated = false;
+ if (mNavMode) {
+ if (MotionEvent.ACTION_DOWN == evt.getActionMasked()) {
+ mDownX = evt.getX();
+ mDownY = evt.getY();
+ mTracking = true;
+ return true;
+ } else if (mTracking && MotionEvent.ACTION_MOVE == evt.getActionMasked()) {
+ if (mSlop < Math.abs(evt.getX() - mDownX)
+ || mSlop < Math.abs(evt.getY() - mDownY)) {
+ mTracking = false;
+ }
+ return mTracking;
+ } else if (mTracking && MotionEvent.ACTION_UP == evt.getActionMasked()) {
+ performClick();
+ mTracking = false;
+ return true;
+ } else if (mTracking && MotionEvent.ACTION_CANCEL == evt.getActionMasked()) {
+ mTracking = false;
+ return true;
+ }
+ return super.onTouchEvent(evt);
+ } else {
+ if (MotionEvent.ACTION_DOWN == evt.getActionMasked()) {
+ mUserInitiated = true;
+ } else if (MotionEvent.ACTION_UP == evt.getActionMasked()
+ || (MotionEvent.ACTION_CANCEL == evt.getActionMasked())) {
+ mUserInitiated = false;
+ }
+ return super.onTouchEvent(evt);
}
- return super.onTouchEvent(evt);
}
@Override
diff --git a/src/com/android/browser/Controller.java b/src/com/android/browser/Controller.java
index 06f00c7..e20a876 100644
--- a/src/com/android/browser/Controller.java
+++ b/src/com/android/browser/Controller.java
@@ -1242,6 +1242,10 @@
}
}
+ protected void onMenuKey() {
+ mUi.onMenuKey();
+ }
+
// menu handling and state
// TODO: maybe put into separate handler
@@ -2458,9 +2462,12 @@
*/
boolean onKeyDown(int keyCode, KeyEvent event) {
boolean noModifiers = event.hasNoModifiers();
-
// Even if MENU is already held down, we need to call to super to open
// the IME on long press.
+ if (KeyEvent.KEYCODE_MENU == keyCode) {
+ event.startTracking();
+ return true;
+ }
if (!noModifiers
&& ((KeyEvent.KEYCODE_MENU == keyCode)
|| (KeyEvent.KEYCODE_CTRL_LEFT == keyCode)
@@ -2584,11 +2591,15 @@
}
boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (KeyEvent.KEYCODE_MENU == keyCode) {
+ mMenuIsDown = false;
+ if (event.isTracking() && !event.isCanceled()) {
+ onMenuKey();
+ return true;
+ }
+ }
if (!event.hasNoModifiers()) return false;
switch(keyCode) {
- case KeyEvent.KEYCODE_MENU:
- mMenuIsDown = false;
- break;
case KeyEvent.KEYCODE_BACK:
if (event.isTracking() && !event.isCanceled()) {
onBackKey();
diff --git a/src/com/android/browser/NavScreen.java b/src/com/android/browser/NavScreen.java
index a5090fa..d872625 100644
--- a/src/com/android/browser/NavScreen.java
+++ b/src/com/android/browser/NavScreen.java
@@ -19,8 +19,6 @@
import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
-import android.graphics.Bitmap;
-import android.graphics.Matrix;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
@@ -28,42 +26,38 @@
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.webkit.WebView;
-import android.widget.AdapterView;
-import android.widget.AdapterView.OnItemClickListener;
-import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.BaseAdapter;
import android.widget.FrameLayout;
-import android.widget.FrameLayout.LayoutParams;
import android.widget.Gallery;
import android.widget.ImageButton;
import android.widget.ImageView;
-import android.widget.ImageView.ScaleType;
-import android.widget.LinearLayout;
import android.widget.ListPopupWindow;
+import android.widget.RelativeLayout;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
-public class NavScreen extends LinearLayout implements OnClickListener {
+public class NavScreen extends RelativeLayout implements OnClickListener {
UiController mUiController;
PhoneUi mUi;
Tab mTab;
Activity mActivity;
- View mTopPanel;
- ImageButton mBack;
ImageButton mRefresh;
ImageButton mForward;
- ImageButton mTabs;
ImageButton mBookmarks;
ImageButton mMore;
ImageButton mNewTab;
ImageButton mNewIncognito;
FrameLayout mHolder;
- Gallery mFlipper;
+ TextView mTitle;
+ ImageView mFavicon;
+ ImageButton mCloseTab;
+
+ NavTabScroller mScroller;
float mTabAspect = 0.66f;
int mTabWidth;
int mTabHeight;
@@ -83,15 +77,15 @@
@Override
public void onMeasure(int wspec, int hspec) {
super.onMeasure(wspec, hspec);
- mTabHeight = mFlipper.getMeasuredHeight();
- mTabWidth = (int) (mTabHeight * mTabAspect);
- if (mAdapter != null) {
- mAdapter.notifyDataSetChanged();
- }
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ mAdapter.notifyDataSetChanged();
}
protected Tab getSelectedTab() {
- return (Tab) mFlipper.getSelectedItem();
+ return (Tab) mScroller.getSelectedItem();
}
protected void showMenu() {
@@ -125,106 +119,42 @@
@Override
protected void onConfigurationChanged(Configuration newconfig) {
if (newconfig.orientation != mOrientation) {
- int selIx = mFlipper.getSelectedItemPosition();
+ int selIx = mScroller.getSelectionIndex();
removeAllViews();
init();
- mFlipper.setSelection(selIx);
+ mScroller.setSelection(selIx);
mOrientation = newconfig.orientation;
+ mAdapter.notifyDataSetChanged();
}
}
private void init() {
LayoutInflater.from(mContext).inflate(R.layout.nav_screen, this);
- LinearLayout content = (LinearLayout) findViewById(R.id.nav_screen);
- mTopPanel = findViewById(R.id.navtop);
- mBack = (ImageButton) findViewById(R.id.back);
- mForward = (ImageButton) findViewById(R.id.forward);
- mRefresh = (ImageButton) findViewById(R.id.refresh);
- mTabs = (ImageButton) findViewById(R.id.tabs);
mBookmarks = (ImageButton) findViewById(R.id.bookmarks);
mNewTab = (ImageButton) findViewById(R.id.newtab);
mNewIncognito = (ImageButton) findViewById(R.id.newincognito);
mMore = (ImageButton) findViewById(R.id.more);
- mBack.setOnClickListener(this);
- mForward.setOnClickListener(this);
- mRefresh.setOnClickListener(this);
- mTabs.setOnClickListener(this);
mBookmarks.setOnClickListener(this);
mNewTab.setOnClickListener(this);
mNewIncognito.setOnClickListener(this);
mMore.setOnClickListener(this);
- mHolder = (FrameLayout) findViewById(R.id.galleryholder);
- FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(
- LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
- mFlipper = new TabGallery(mContext);
- mFlipper.setSpacing((int)(mContext.getResources()
- .getDimension(R.dimen.nav_tab_spacing)));
- mFlipper.setUnselectedAlpha(0.8f);
- mFlipper.setLayoutParams(lp);
- mHolder.addView(mFlipper, 0);
+ mScroller = (NavTabScroller) findViewById(R.id.scroller);
mAdapter = new TabAdapter(mContext, mUiController.getTabControl());
- mFlipper.setAdapter(mAdapter);
- setTab(mUi.getActiveTab(), true);
- mFlipper.setOnItemClickListener(new OnItemClickListener() {
- @Override
- public void onItemClick(AdapterView<?> parent, View view,
- int position, long id) {
- // post as runnable to prevent bug in gesturedetector
- // when view is removed in click handler
- // sends action_cancel before action_up
- mFlipper.post(new Runnable() {
- public void run() {
- close();
- }
- });
- }
- });
- mFlipper.setOnItemSelectedListener(new OnItemSelectedListener() {
- @Override
- public void onItemSelected(AdapterView<?> parent, View view,
- int position, long id) {
- final Tab tab = mAdapter.getItem(position);
- setTab(tab, false);
- }
+ mScroller.setAdapter(mAdapter);
- @Override
- public void onNothingSelected(AdapterView<?> parent) {
- }
- });
- }
-
- private void setTab(Tab tab, boolean updateFlipper) {
- mTab = tab;
- // refresh state from tab
- WebView web = tab.getWebView();
- if (web != null) {
- mBack.setImageResource(web.canGoBack()
- ? R.drawable.ic_back_holo_dark
- : R.drawable.ic_back_disabled_holo_dark);
- mForward.setImageResource(web.canGoForward()
- ? R.drawable.ic_forward_holo_dark
- : R.drawable.ic_forward_disabled_holo_dark);
- }
- if (updateFlipper) {
- mFlipper.setSelection(mUiController.getTabControl().getTabPosition(tab));
- }
+ // update state for active tab
+ mScroller.setSelection(mUiController.getTabControl().getTabPosition(mUi.getActiveTab()));
}
@Override
public void onClick(View v) {
WebView web = (mTab != null) ? mTab.getWebView() : null;
if (web != null) {
- if (mBack == v) {
+ if (mForward == v) {
mUi.hideNavScreen(true);
- switchToSelected();
- web.goBack();
- } else if (mForward == v) {
- mUi.hideNavScreen(true);
- switchToSelected();
web.goForward();
} else if (mRefresh == v) {
mUi.hideNavScreen(true);
- switchToSelected();
web.reload();
}
}
@@ -232,7 +162,6 @@
mUi.hideNavScreen(false);
switchToSelected();
mUiController.bookmarksOrHistoryPicker(false);
- } else if (mTabs == v) {
} else if (mNewTab == v) {
openNewTab();
} else if (mMore == v) {
@@ -240,39 +169,47 @@
} else if (mNewIncognito == v) {
mUi.hideNavScreen(true);
mUiController.openIncognitoTab();
+ } else if (mTitle == v) {
+ mUi.getTitleBar().setSkipTitleBarAnimations(true);
+ close(false);
+ mUi.editUrl(false);
+ mUi.getTitleBar().setSkipTitleBarAnimations(false);
}
}
- private void openNewTab() {
- Tab tab = mUiController.openTabToHomePage();
- mAdapter.notifyDataSetChanged();
+ private void onCloseTab(Tab tab) {
+ if (tab != null) {
+ mUiController.closeTab(tab);
+ if (mUiController.getTabControl().getTabCount() == 0) {
+ openNewTab();
+ } else {
+ mAdapter.notifyDataSetChanged();
+ }
+ }
+ }
+
+ private void openNewTab() {
+ // need to call openTab explicitely with setactive false
+ Tab tab = mUiController.openTab(BrowserSettings.getInstance().getHomePage(),
+ false, false, false);
+ mAdapter.notifyDataSetChanged();
if (tab != null) {
// set tab as the selected in flipper, then hide
final int tix = mUi.mTabControl.getTabPosition(tab);
- post(new Runnable() {
+ mScroller.setSelection(tix);
+ postDelayed(new Runnable() {
+ @Override
public void run() {
- if (tix != -1) {
- for (int i = mFlipper.getSelectedItemPosition();
- i <= tix; i++) {
- mFlipper.setSelection(i, true);
- mFlipper.invalidate();
- try {
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
mUi.hideNavScreen(true);
switchToSelected();
}
- });
+ }, 100);
}
}
private void switchToSelected() {
- Tab tab = (Tab) mFlipper.getSelectedItem();
+ Tab tab = (Tab) mScroller.getSelectedItem();
if (tab != mUi.getActiveTab()) {
mUiController.setActiveTab(tab);
}
@@ -284,7 +221,6 @@
protected void close(boolean animate) {
mUi.hideNavScreen(animate);
- switchToSelected();
}
class TabGallery extends Gallery {
@@ -296,8 +232,7 @@
@Override
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
- return new Gallery.LayoutParams(
- LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+ return new Gallery.LayoutParams(mTabWidth, mTabHeight);
}
@Override
@@ -317,18 +252,6 @@
tabControl = tc;
}
- void onCloseTab(Tab tab) {
- if (tab != null) {
- mUiController.closeTab(tab);
- if (tabControl.getTabCount() == 0) {
- mUiController.openTabToHomePage();
- mUi.hideNavScreen(false);
- } else {
- notifyDataSetChanged();
- }
- }
- }
-
@Override
public int getCount() {
return tabControl.getTabCount();
@@ -344,55 +267,69 @@
}
@Override
- public View getView(int position, View convertView, ViewGroup parent) {
- ImageView content = null;
+ public View getView(final int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = LayoutInflater.from(context).inflate(R.layout.nav_tab_view,
null);
- content = (ImageView) convertView.findViewById(R.id.content);
- content.setLayoutParams(new LayoutParams(mTabWidth, mTabHeight));
- } else {
- content = (ImageView) convertView.findViewById(R.id.content);
- content.setLayoutParams(new LayoutParams(mTabWidth, mTabHeight));
}
- View tbar = convertView.findViewById(R.id.titlebar);
- TextView title = (TextView) convertView.findViewById(R.id.title);
- ImageView icon = (ImageView) convertView.findViewById(R.id.favicon);
- ImageButton close = (ImageButton) convertView.findViewById(R.id.closetab);
final Tab tab = getItem(position);
- icon.setImageDrawable(mUi.getFaviconDrawable(tab.getFavicon()));
- title.setText(tab.getUrl());
- content.setScaleType(ScaleType.MATRIX);
- Matrix matrix = new Matrix();
- Bitmap screen = tab.getScreenshot();
- if (screen != null) {
- float scale = 1.0f;
- if (mTabWidth > mTabHeight) {
- scale = mTabWidth / (float) screen.getWidth();
- } else {
- scale = mTabHeight / (float) screen.getHeight();
- }
- matrix.setScale(scale, scale);
- content.setImageMatrix(matrix);
- content.setImageBitmap(screen);
- }
+ final BrowserWebView web = (BrowserWebView) tab.getWebView();
+ removeFromParent(web);
+ FrameLayout mview = (FrameLayout) convertView.findViewById(R.id.tab_view);
+ mview.addView(web, 0);
+ ImageButton close = (ImageButton) convertView.findViewById(R.id.closetab);
close.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
- onCloseTab(tab);
+ onCloseTab((Tab) (mScroller.getSelectedItem()));
}
});
- tbar.setOnClickListener(new OnClickListener() {
+ web.setNavMode(true);
+ web.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
- close(false);
+ mScroller.setSelection(position);
+ close();
+ }
+ });
+ ImageButton forward = (ImageButton) convertView.findViewById(R.id.forward);
+ ImageButton refresh = (ImageButton) convertView.findViewById(R.id.refresh);
+ TextView title = (TextView) convertView.findViewById(R.id.title);
+ ImageView favicon = (ImageView) convertView.findViewById(R.id.favicon);
+ if (web != null) {
+ forward.setVisibility(web.canGoForward()
+ ? View.VISIBLE : View.GONE);
+ }
+ // refresh titlebar
+ favicon.setImageDrawable(mUi.getFaviconDrawable(tab.getFavicon()));
+ title.setText(tab.getUrl());
+ title.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
mUi.getTitleBar().setSkipTitleBarAnimations(true);
+ close(false);
mUi.editUrl(false);
mUi.getTitleBar().setSkipTitleBarAnimations(false);
}
});
+ forward.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mUi.hideNavScreen(true);
+ web.goForward();
+ }
+ });
+ refresh.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mUi.hideNavScreen(true);
+ web.reload();
+ }
+ });
+
return convertView;
}
+
}
private class MenuAdapter extends BaseAdapter implements OnClickListener {
@@ -454,4 +391,10 @@
}
+ private static void removeFromParent(View v) {
+ if (v.getParent() != null) {
+ ((ViewGroup) v.getParent()).removeView(v);
+ }
+ }
+
}
diff --git a/src/com/android/browser/NavTabScroller.java b/src/com/android/browser/NavTabScroller.java
new file mode 100644
index 0000000..dc5627a
--- /dev/null
+++ b/src/com/android/browser/NavTabScroller.java
@@ -0,0 +1,186 @@
+/*
+ * 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 com.android.browser.view.HorizontalScrollView;
+
+import android.content.Context;
+import android.database.DataSetObserver;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.LinearLayout;
+
+/**
+ * custom view for displaying tabs in the nav screen
+ */
+public class NavTabScroller extends HorizontalScrollView {
+
+ private static final float DEFAULT_ALPHA = 0.5f;
+
+ private LinearLayout mContentView;
+ private int mSelected;
+ private BaseAdapter mAdapter;
+ private boolean mSnapScroll;
+
+ 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) {
+ setHorizontalScrollBarEnabled(false);
+ mContentView = new LinearLayout(ctx);
+ mContentView.setOrientation(LinearLayout.HORIZONTAL);
+ int pad = ctx.getResources().getDimensionPixelSize(R.dimen.nav_scroller_padding);
+ mContentView.setPadding(pad, 0, pad, 0);
+ mContentView.setLayoutParams(
+ new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT));
+ addView(mContentView);
+ mSelected = -1;
+ }
+
+ protected void setAdapter(BaseAdapter adapter) {
+ mAdapter = adapter;
+ mAdapter.registerDataSetObserver(new DataSetObserver() {
+
+ @Override
+ public void onChanged() {
+ super.onChanged();
+ populateList();
+ }
+
+ @Override
+ public void onInvalidated() {
+ super.onInvalidated();
+ }
+ });
+ populateList();
+ }
+
+ protected void setSelection(int ix) {
+ mSelected = ix;
+ updateViewAlpha();
+ }
+
+ private void updateViewAlpha() {
+ final int n = mContentView.getChildCount();
+ for (int i = 0; i < n; i ++) {
+ View v = mContentView.getChildAt(i);
+ v.setAlpha((i == mSelected) ? 1.0f : DEFAULT_ALPHA);
+ }
+ }
+
+ protected int getSelectionIndex() {
+ return mSelected;
+ }
+
+ protected Tab getSelectedItem() {
+ return (Tab) mAdapter.getItem(mSelected);
+ }
+
+ protected ViewGroup getContentView() {
+ return mContentView;
+ }
+
+ private void populateList() {
+ clearTabs();
+ for (int i = 0; i < mAdapter.getCount(); i++) {
+ View v = mAdapter.getView(i, null, mContentView);
+ mContentView.addView(v);
+ v.setAlpha((i == mSelected) ? 1.0f : DEFAULT_ALPHA);
+ }
+ }
+
+ View getSelectedTab() {
+ if ((mSelected >= 0) && (mSelected < mContentView.getChildCount())) {
+ return mContentView.getChildAt(mSelected);
+ } else {
+ return null;
+ }
+ }
+
+ void clearTabs() {
+ for (int i = 0; i < mContentView.getChildCount(); i++) {
+ ViewGroup vg = (ViewGroup) mContentView.getChildAt(i);
+ vg.removeViewAt(0);
+ }
+ mContentView.removeAllViews();
+ }
+
+ protected void onScrollChanged(int sl, int st, int ol, int ot) {
+ int midx = getScrollX() + getWidth() / 2;
+ int sel = -1;
+ for (int i = 0; i < mContentView.getChildCount(); i++) {
+ View child = mContentView.getChildAt(i);
+ if (child.getLeft() < midx && child.getRight() > midx) {
+ sel = i;
+ break;
+ }
+ }
+ if (sel != -1 && sel != mSelected) {
+ setSelection(sel);
+ }
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent evt) {
+ boolean dragged = mIsBeingDragged;
+ boolean result = super.onTouchEvent(evt);
+ if (MotionEvent.ACTION_UP == evt.getActionMasked()) {
+ if (mScroller.isFinished() && dragged) {
+ snapToSelected();
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public void computeScroll() {
+ super.computeScroll();
+ if (mScroller.isFinished() && !mIsBeingDragged) {
+ if (!mSnapScroll) {
+ snapToSelected();
+ } else {
+ // reset snap scrolling flag
+ mSnapScroll = false;
+ }
+ }
+ }
+
+ private void snapToSelected() {
+ // snap to selected
+ mSnapScroll = true;
+ View v = mContentView.getChildAt(mSelected);
+ int left = (v.getLeft() + v.getRight()) / 2;
+ left -= getWidth() / 2;
+ scrollTo(left,0);
+ }
+
+}
diff --git a/src/com/android/browser/PhoneUi.java b/src/com/android/browser/PhoneUi.java
index e838cd4..80fdcfa 100644
--- a/src/com/android/browser/PhoneUi.java
+++ b/src/com/android/browser/PhoneUi.java
@@ -16,10 +16,6 @@
package com.android.browser;
-import android.animation.Animator;
-import android.animation.Animator.AnimatorListener;
-import android.animation.AnimatorSet;
-import android.animation.ObjectAnimator;
import android.app.Activity;
import android.util.Log;
import android.view.ActionMode;
@@ -110,18 +106,18 @@
}
@Override
+ public boolean onMenuKey() {
+ if (mNavScreen == null) {
+ showNavScreen();
+ } else {
+ mNavScreen.close();
+ }
+ return true;
+ }
+
+ @Override
public boolean dispatchKey(int code, KeyEvent event) {
if (!isComboViewShowing()) {
- switch (code) {
- case KeyEvent.KEYCODE_MENU:
- if (mNavScreen == null) {
- showNavScreen();
- return true;
- } else {
- mNavScreen.close();
- return true;
- }
- }
}
return false;
}
@@ -166,6 +162,7 @@
Log.e(LOGTAG, "active tab with no webview detected");
return;
}
+ view.setNavMode(false);
// Request focus on the top window.
if (mUseQuickControls) {
mPieControl.forceToTop(mContentView);
@@ -295,125 +292,24 @@
}
}
}
-
void showNavScreen() {
- if (mAnimating) return;
- mAnimating = true;
+ detachTab(mActiveTab);
mNavScreen = new NavScreen(mActivity, mUiController, this);
- float yoffset = 0;
- WebView web = getWebView();
- if (web != null) {
- yoffset = mNavScreen.getToolbarHeight() -
- web.getVisibleTitleHeight();
- }
// Add the custom view to its container.
- mCustomViewContainer.addView(mNavScreen, COVER_SCREEN_GRAVITY_CENTER);
- mContentView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
- ObjectAnimator animx = ObjectAnimator.ofFloat(mContentView,
- "scaleX", 1.0f, NAV_TAB_SCALE);
- ObjectAnimator animy = ObjectAnimator.ofFloat(mContentView,
- "scaleY", 1.0f, NAV_TAB_SCALE);
- ObjectAnimator translatey = ObjectAnimator.ofFloat(mContentView,
- "translationY", 0, yoffset * NAV_TAB_SCALE);
- AnimatorSet anims = new AnimatorSet();
- anims.setDuration(200);
- anims.addListener(new AnimatorListener() {
-
- @Override
- public void onAnimationCancel(Animator animation) {
- }
-
- @Override
- public void onAnimationEnd(Animator animation) {
- finishShowNavScreen();
- }
-
- @Override
- public void onAnimationRepeat(Animator animation) {
- }
-
- @Override
- public void onAnimationStart(Animator animation) {
- }
- });
- anims.playTogether(animx, animy, translatey);
- anims.start();
- }
-
- private void finishShowNavScreen() {
- // Hide the content view.
- mContentView.setLayerType(View.LAYER_TYPE_NONE, null);
+ mCustomViewContainer.addView(mNavScreen, COVER_SCREEN_PARAMS);
mContentView.setVisibility(View.GONE);
- mContentView.setScaleX(1.0f);
- mContentView.setScaleY(1.0f);
- mContentView.setTranslationY(0);
- BrowserWebView web = (BrowserWebView) getWebView();
- if (web != null) {
- mActiveTab.setScreenshot(web.capture());
- }
- // Finally show the custom view container.
mCustomViewContainer.setVisibility(View.VISIBLE);
mCustomViewContainer.bringToFront();
- mAnimating = false;
}
- void hideNavScreen(boolean animateToPage) {
- if (mAnimating || mNavScreen == null) return;
- mAnimating = true;
- mNavScreen.setLayerType(View.LAYER_TYPE_HARDWARE, null);
- if (animateToPage) {
- float yoffset = 0;
- WebView web = mNavScreen.getSelectedTab().getWebView();
- if (web != null) {
- yoffset = mNavScreen.getToolbarHeight() -
- web.getVisibleTitleHeight();
- }
- ObjectAnimator animx = ObjectAnimator.ofFloat(mNavScreen, "scaleX",
- 1.0f, 1 / NAV_TAB_SCALE);
- ObjectAnimator animy = ObjectAnimator.ofFloat(mNavScreen, "scaleY",
- 1.0f, 1 / NAV_TAB_SCALE);
- ObjectAnimator translatey = ObjectAnimator.ofFloat(mNavScreen,
- "translationY", 0, -yoffset);
- AnimatorSet anims = new AnimatorSet();
- anims.setDuration(200);
- anims.addListener(new AnimatorListener() {
-
- @Override
- public void onAnimationCancel(Animator animation) {
- }
-
- @Override
- public void onAnimationEnd(Animator animation) {
- finishHideNavScreen();
- }
-
- @Override
- public void onAnimationRepeat(Animator animation) {
- }
-
- @Override
- public void onAnimationStart(Animator animation) {
- }
- });
- anims.playTogether(animx, animy, translatey);
- anims.start();
- } else {
- finishHideNavScreen();
- }
-
- }
-
- private void finishHideNavScreen() {
- // Hide the custom view.
- mNavScreen.setVisibility(View.GONE);
- mNavScreen.setLayerType(View.LAYER_TYPE_NONE, null);
- // Remove the custom view from its container.
+ void hideNavScreen(boolean animate) {
+ Tab tab = mNavScreen.getSelectedTab();
mCustomViewContainer.removeView(mNavScreen);
mNavScreen = null;
mCustomViewContainer.setVisibility(View.GONE);
+ mUiController.setActiveTab(tab);
// Show the content view.
mContentView.setVisibility(View.VISIBLE);
- mAnimating = false;
}
}
diff --git a/src/com/android/browser/TitleBarPhone.java b/src/com/android/browser/TitleBarPhone.java
index 9242f99..97fe747 100644
--- a/src/com/android/browser/TitleBarPhone.java
+++ b/src/com/android/browser/TitleBarPhone.java
@@ -20,12 +20,16 @@
import android.app.Activity;
import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
import android.view.ContextMenu;
import android.view.MenuInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
+import android.webkit.WebView;
import android.widget.FrameLayout;
+import android.widget.ImageButton;
import android.widget.ImageView;
import java.util.List;
@@ -41,6 +45,9 @@
private ImageView mStopButton;
private ImageView mVoiceButton;
private boolean mHasLockIcon;
+ private ImageButton mForward;
+ private Drawable mStopDrawable;
+ private Drawable mRefreshDrawable;
public TitleBarPhone(Activity activity, UiController controller, PhoneUi ui,
FrameLayout parent) {
@@ -58,7 +65,12 @@
mStopButton.setOnClickListener(this);
mVoiceButton = (ImageView) findViewById(R.id.voice);
mVoiceButton.setOnClickListener(this);
+ mForward = (ImageButton) findViewById(R.id.forward);
+ mForward.setOnClickListener(this);
setFocusState(false);
+ Resources res = context.getResources();
+ mStopDrawable = res.getDrawable(R.drawable.ic_stop_holo_dark);
+ mRefreshDrawable = res.getDrawable(R.drawable.ic_refresh_holo_dark);
}
@Override
@@ -91,11 +103,7 @@
mVoiceButton.setVisibility(View.VISIBLE);
} else {
mLockIcon.setVisibility(mHasLockIcon ? View.VISIBLE : View.GONE);
- if (mInLoad) {
- mStopButton.setVisibility(View.VISIBLE);
- } else {
- mStopButton.setVisibility(View.GONE);
- }
+ mStopButton.setVisibility(View.VISIBLE);
mVoiceButton.setVisibility(View.GONE);
}
}
@@ -110,6 +118,17 @@
setFocusState(mUrlInput.hasFocus());
}
+ @Override
+ void setProgress(int progress) {
+ super.setProgress(progress);
+ if (progress == 100) {
+ mStopButton.setImageDrawable(mRefreshDrawable);
+ } else if (mStopButton.getDrawable() != mStopDrawable) {
+ mStopButton.setImageDrawable(mStopDrawable);
+ }
+ updateNavigationState();
+ }
+
/**
* Update the text displayed in the title bar.
* @param title String to display. If null, the new tab string will be
@@ -122,6 +141,8 @@
} else {
mUrlInput.setText(title);
}
+ mUrlInput.setSelection(0);
+ updateNavigationState();
}
@Override
@@ -140,12 +161,31 @@
@Override
public void onClick(View v) {
if (v == mStopButton) {
- mUiController.stopLoading();
+ if (mInLoad) {
+ mUiController.stopLoading();
+ } else {
+ WebView web = mBaseUi.getWebView();
+ if (web != null) {
+ web.reload();
+ }
+ }
} else if (v == mVoiceButton) {
mUiController.startVoiceSearch();
+ } else if (v == mForward) {
+ WebView web = mBaseUi.getWebView();
+ if (web != null) {
+ web.goForward();
+ }
} else {
super.onClick(v);
}
}
+ private void updateNavigationState() {
+ WebView web = mBaseUi.getWebView();
+ if (web != null) {
+ mForward.setVisibility(web.canGoForward() ? View.VISIBLE : View.GONE);
+ }
+ }
+
}
diff --git a/src/com/android/browser/UI.java b/src/com/android/browser/UI.java
index bb34ada..22851f1 100644
--- a/src/com/android/browser/UI.java
+++ b/src/com/android/browser/UI.java
@@ -43,6 +43,8 @@
public boolean onBackKey();
+ public boolean onMenuKey();
+
public boolean needsRestoreAllTabs();
public void addTab(Tab tab);
diff --git a/src/com/android/browser/view/HorizontalScrollView.java b/src/com/android/browser/view/HorizontalScrollView.java
new file mode 100644
index 0000000..2da9058
--- /dev/null
+++ b/src/com/android/browser/view/HorizontalScrollView.java
@@ -0,0 +1,1453 @@
+/*
+ * Copyright (C) 2009 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 com.android.internal.R;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+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.animation.AnimationUtils;
+import android.widget.EdgeGlow;
+import android.widget.FrameLayout;
+import android.widget.OverScroller;
+
+import java.util.List;
+
+// copied from frameworks to allow for customizations
+public class HorizontalScrollView extends FrameLayout {
+
+ private static final int ANIMATED_SCROLL_GAP = 250;
+
+ private static final float MAX_SCROLL_FACTOR = 0.5f;
+
+
+ private long mLastScroll;
+
+ private final Rect mTempRect = new Rect();
+ protected OverScroller mScroller;
+ private EdgeGlow mEdgeGlowLeft;
+ private EdgeGlow mEdgeGlowRight;
+
+ /**
+ * Position of the last motion event.
+ */
+ private float mLastMotionX;
+
+ /**
+ * True when the layout has changed but the traversal has not come through yet.
+ * Ideally the view hierarchy would keep track of this for us.
+ */
+ private boolean mIsLayoutDirty = true;
+
+ /**
+ * The child to give focus to in the event that a child has requested focus while the
+ * layout is dirty. This prevents the scroll from being wrong if the child has not been
+ * laid out before requesting focus.
+ */
+ private View mChildToScrollTo = null;
+
+ /**
+ * True if the user is currently dragging this 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;
+ private 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;
+
+ /**
+ * Sentinel value for no current active pointer.
+ * Used by {@link #mActivePointerId}.
+ */
+ private static final int INVALID_POINTER = -1;
+
+ public HorizontalScrollView(Context context) {
+ this(context, null);
+ }
+
+ public HorizontalScrollView(Context context, AttributeSet attrs) {
+ this(context, attrs, com.android.internal.R.attr.horizontalScrollViewStyle);
+ }
+
+ public HorizontalScrollView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ initScrollView();
+
+ TypedArray a = context.obtainStyledAttributes(attrs,
+ android.R.styleable.HorizontalScrollView, defStyle, 0);
+
+ setFillViewport(a.getBoolean(android.R.styleable.HorizontalScrollView_fillViewport, false));
+
+ a.recycle();
+ }
+
+ @Override
+ protected float getLeftFadingEdgeStrength() {
+ return 0.0f;
+ }
+
+ @Override
+ protected float getRightFadingEdgeStrength() {
+ return 0.0f;
+ }
+
+ /**
+ * @return The maximum amount this scroll view will scroll in response to
+ * an arrow event.
+ */
+ public int getMaxScrollAmount() {
+ return (int) (MAX_SCROLL_FACTOR * (mRight - mLeft));
+ }
+
+
+ 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();
+ }
+
+ @Override
+ public void addView(View child) {
+ if (getChildCount() > 0) {
+ throw new IllegalStateException("HorizontalScrollView can host only one direct child");
+ }
+
+ super.addView(child);
+ }
+
+ @Override
+ public void addView(View child, int index) {
+ if (getChildCount() > 0) {
+ throw new IllegalStateException("HorizontalScrollView 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("HorizontalScrollView 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("HorizontalScrollView can host only one direct child");
+ }
+
+ super.addView(child, index, params);
+ }
+
+ /**
+ * @return Returns true this HorizontalScrollView can be scrolled
+ */
+ private boolean canScroll() {
+ View child = getChildAt(0);
+ if (child != null) {
+ int childWidth = child.getWidth();
+ return getWidth() < childWidth + mPaddingLeft + mPaddingRight ;
+ }
+ return false;
+ }
+
+ /**
+ * Indicates whether this HorizontalScrollView's content is stretched to
+ * fill the viewport.
+ *
+ * @return True if the content fills the viewport, false otherwise.
+ *
+ * @attr ref android.R.styleable#HorizontalScrollView_fillViewport
+ */
+ public boolean isFillViewport() {
+ return mFillViewport;
+ }
+
+ /**
+ * Indicates this HorizontalScrollView whether it should stretch its content width
+ * to fill the viewport or not.
+ *
+ * @param fillViewport True to stretch the content's width to the viewport's
+ * boundaries, false otherwise.
+ *
+ * @attr ref android.R.styleable#HorizontalScrollView_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 widthMode = MeasureSpec.getMode(widthMeasureSpec);
+ if (widthMode == MeasureSpec.UNSPECIFIED) {
+ return;
+ }
+
+ if (getChildCount() > 0) {
+ final View child = getChildAt(0);
+ 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);
+ }
+ }
+ }
+
+ @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()) {
+ View currentFocused = findFocus();
+ if (currentFocused == this) currentFocused = null;
+ View nextFocused = FocusFinder.getInstance().findNextFocus(this,
+ currentFocused, View.FOCUS_RIGHT);
+ return nextFocused != null && nextFocused != this &&
+ nextFocused.requestFocus(View.FOCUS_RIGHT);
+ }
+ return false;
+ }
+
+ boolean handled = false;
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ switch (event.getKeyCode()) {
+ case KeyEvent.KEYCODE_DPAD_LEFT:
+ if (!event.isAltPressed()) {
+ handled = arrowScroll(View.FOCUS_LEFT);
+ } else {
+ handled = fullScroll(View.FOCUS_LEFT);
+ }
+ break;
+ case KeyEvent.KEYCODE_DPAD_RIGHT:
+ if (!event.isAltPressed()) {
+ handled = arrowScroll(View.FOCUS_RIGHT);
+ } else {
+ handled = fullScroll(View.FOCUS_RIGHT);
+ }
+ break;
+ case KeyEvent.KEYCODE_SPACE:
+ pageScroll(event.isShiftPressed() ? View.FOCUS_LEFT : View.FOCUS_RIGHT);
+ break;
+ }
+ }
+
+ return handled;
+ }
+
+ private boolean inChild(int x, int y) {
+ if (getChildCount() > 0) {
+ final int scrollX = mScrollX;
+ final View child = getChildAt(0);
+ return !(y < child.getTop()
+ || y >= child.getBottom()
+ || x < child.getLeft() - scrollX
+ || x >= child.getRight() - scrollX);
+ }
+ return false;
+ }
+
+ @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;
+ }
+
+ 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. mLastMotionX is set to the x 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 x = ev.getX(pointerIndex);
+ final int xDiff = (int) Math.abs(x - mLastMotionX);
+ if (xDiff > mTouchSlop) {
+ mIsBeingDragged = true;
+ mLastMotionX = x;
+ if (mParent != null) mParent.requestDisallowInterceptTouchEvent(true);
+ }
+ break;
+ }
+
+ case MotionEvent.ACTION_DOWN: {
+ final float x = ev.getX();
+ if (!inChild((int) x, (int) ev.getY())) {
+ mIsBeingDragged = false;
+ break;
+ }
+
+ /*
+ * Remember location of down touch.
+ * ACTION_DOWN always refers to pointer index 0.
+ */
+ mLastMotionX = x;
+ 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 = !mScroller.isFinished();
+ break;
+ }
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ /* Release the drag */
+ mIsBeingDragged = false;
+ mActivePointerId = INVALID_POINTER;
+ if (mScroller.springBack(mScrollX, mScrollY, 0, getScrollRange(), 0, 0)) {
+ invalidate();
+ }
+ break;
+ case MotionEvent.ACTION_POINTER_DOWN: {
+ final int index = ev.getActionIndex();
+ mLastMotionX = ev.getX(index);
+ mActivePointerId = ev.getPointerId(index);
+ break;
+ }
+ case MotionEvent.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
+ break;
+ }
+
+ /*
+ * The only time we want to intercept motion events is if we are in the
+ * drag mode.
+ */
+ return mIsBeingDragged;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+
+ if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
+ // Don't handle edge touches immediately -- they may actually belong to one of our
+ // descendants.
+ return false;
+ }
+
+ if (mVelocityTracker == null) {
+ mVelocityTracker = VelocityTracker.obtain();
+ }
+ 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();
+ }
+
+ // Remember where the motion event started
+ mLastMotionX = ev.getX();
+ mActivePointerId = ev.getPointerId(0);
+ break;
+ }
+ case MotionEvent.ACTION_MOVE:
+ if (mIsBeingDragged) {
+ // Scroll to follow the motion event
+ final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
+ final float x = ev.getX(activePointerIndex);
+ final int deltaX = (int) (mLastMotionX - x);
+ mLastMotionX = x;
+
+ final int oldX = mScrollX;
+ final int oldY = mScrollY;
+ final int range = getScrollRange();
+ if (overScrollBy(deltaX, 0, mScrollX, 0, range, 0,
+ mOverscrollDistance, 0, 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 pulledToX = oldX + deltaX;
+ if (pulledToX < 0) {
+ mEdgeGlowLeft.onPull((float) deltaX / getWidth());
+ if (!mEdgeGlowRight.isFinished()) {
+ mEdgeGlowRight.onRelease();
+ }
+ } else if (pulledToX > range) {
+ mEdgeGlowRight.onPull((float) deltaX / getWidth());
+ if (!mEdgeGlowLeft.isFinished()) {
+ mEdgeGlowLeft.onRelease();
+ }
+ }
+ if (mEdgeGlowLeft != null
+ && (!mEdgeGlowLeft.isFinished() || !mEdgeGlowRight.isFinished())) {
+ invalidate();
+ }
+ }
+ }
+ break;
+ case MotionEvent.ACTION_UP:
+ if (mIsBeingDragged) {
+ final VelocityTracker velocityTracker = mVelocityTracker;
+ velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
+ int initialVelocity = (int) velocityTracker.getXVelocity(mActivePointerId);
+
+ if (getChildCount() > 0) {
+ if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
+ fling(-initialVelocity);
+ } else {
+ final int right = getScrollRange();
+ if (mScroller.springBack(mScrollX, mScrollY, 0, right, 0, 0)) {
+ invalidate();
+ }
+ }
+ }
+
+ mActivePointerId = INVALID_POINTER;
+ mIsBeingDragged = false;
+
+ if (mVelocityTracker != null) {
+ mVelocityTracker.recycle();
+ mVelocityTracker = null;
+ }
+ if (mEdgeGlowLeft != null) {
+ mEdgeGlowLeft.onRelease();
+ mEdgeGlowRight.onRelease();
+ }
+ }
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ if (mIsBeingDragged && getChildCount() > 0) {
+ if (mScroller.springBack(mScrollX, mScrollY, 0, getScrollRange(), 0, 0)) {
+ invalidate();
+ }
+ mActivePointerId = INVALID_POINTER;
+ mIsBeingDragged = false;
+ if (mVelocityTracker != null) {
+ mVelocityTracker.recycle();
+ mVelocityTracker = null;
+ }
+ if (mEdgeGlowLeft != null) {
+ mEdgeGlowLeft.onRelease();
+ mEdgeGlowRight.onRelease();
+ }
+ }
+ break;
+ case MotionEvent.ACTION_POINTER_UP:
+ onSecondaryPointerUp(ev);
+ break;
+ }
+ return true;
+ }
+
+ 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;
+ mLastMotionX = ev.getX(newPointerIndex);
+ mActivePointerId = ev.getPointerId(newPointerIndex);
+ if (mVelocityTracker != null) {
+ mVelocityTracker.clear();
+ }
+ }
+ }
+
+ @Override
+ public boolean onGenericMotionEvent(MotionEvent event) {
+ if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_SCROLL: {
+ if (!mIsBeingDragged) {
+ final float hscroll;
+ if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) {
+ hscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+ } else {
+ 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;
+ }
+ }
+ }
+ }
+ }
+ }
+ return super.onGenericMotionEvent(event);
+ }
+
+ @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 (clampedX) {
+ mScroller.springBack(mScrollX, mScrollY, 0, getScrollRange(), 0, 0);
+ }
+ } else {
+ super.scrollTo(scrollX, scrollY);
+ }
+ awakenScrollBars();
+ }
+
+ private int getScrollRange() {
+ int scrollRange = 0;
+ if (getChildCount() > 0) {
+ View child = getChildAt(0);
+ scrollRange = Math.max(0,
+ child.getWidth() - (getWidth() - mPaddingLeft - mPaddingRight));
+ }
+ return scrollRange;
+ }
+
+ /**
+ * <p>
+ * Finds the next focusable component that fits in this View's bounds
+ * (excluding fading edges) pretending that this View's left is located at
+ * the parameter left.
+ * </p>
+ *
+ * @param leftFocus look for a candidate is the one at the left of the bounds
+ * if leftFocus is true, or at the right of the bounds if leftFocus
+ * is false
+ * @param left the left 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 leftFocus,
+ final int left, View preferredFocusable) {
+ /*
+ * The fading edge's transparent side should be considered for focus
+ * since it's mostly visible, so we divide the actual fading edge length
+ * by 2.
+ */
+ final int fadingEdgeLength = getHorizontalFadingEdgeLength() / 2;
+ final int leftWithoutFadingEdge = left + fadingEdgeLength;
+ final int rightWithoutFadingEdge = left + getWidth() - fadingEdgeLength;
+
+ if ((preferredFocusable != null)
+ && (preferredFocusable.getLeft() < rightWithoutFadingEdge)
+ && (preferredFocusable.getRight() > leftWithoutFadingEdge)) {
+ return preferredFocusable;
+ }
+
+ return findFocusableViewInBounds(leftFocus, leftWithoutFadingEdge,
+ rightWithoutFadingEdge);
+ }
+
+ /**
+ * <p>
+ * Finds the next focusable component that fits in the specified bounds.
+ * </p>
+ *
+ * @param leftFocus look for a candidate is the one at the left of the bounds
+ * if leftFocus is true, or at the right of the bounds if
+ * leftFocus is false
+ * @param left the left offset of the bounds in which a focusable must be
+ * found
+ * @param right the right 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 leftFocus, int left, int right) {
+
+ List<View> focusables = getFocusables(View.FOCUS_FORWARD);
+ View focusCandidate = null;
+
+ /*
+ * A fully contained focusable is one where its left is below the bound's
+ * left, and its right is above the bound's right. 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 viewLeft = view.getLeft();
+ int viewRight = view.getRight();
+
+ if (left < viewRight && viewLeft < right) {
+ /*
+ * the focusable is in the target area, it is a candidate for
+ * focusing
+ */
+
+ final boolean viewIsFullyContained = (left < viewLeft) &&
+ (viewRight < right);
+
+ if (focusCandidate == null) {
+ /* No candidate, take this one */
+ focusCandidate = view;
+ foundFullyContainedFocusable = viewIsFullyContained;
+ } else {
+ final boolean viewIsCloserToBoundary =
+ (leftFocus && viewLeft < focusCandidate.getLeft()) ||
+ (!leftFocus && viewRight > focusCandidate.getRight());
+
+ 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;
+ }
+
+ /**
+ * <p>Handles scrolling in response to a "page up/down" shortcut press. This
+ * method will scroll the view by one page left or right and give the focus
+ * to the leftmost/rightmost 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_LEFT}
+ * to go one page left or {@link android.view.View#FOCUS_RIGHT}
+ * to go one page right
+ * @return true if the key event is consumed by this method, false otherwise
+ */
+ public boolean pageScroll(int direction) {
+ boolean right = direction == View.FOCUS_RIGHT;
+ int width = getWidth();
+
+ if (right) {
+ mTempRect.left = getScrollX() + width;
+ int count = getChildCount();
+ if (count > 0) {
+ View view = getChildAt(0);
+ if (mTempRect.left + width > view.getRight()) {
+ mTempRect.left = view.getRight() - width;
+ }
+ }
+ } else {
+ mTempRect.left = getScrollX() - width;
+ if (mTempRect.left < 0) {
+ mTempRect.left = 0;
+ }
+ }
+ mTempRect.right = mTempRect.left + width;
+
+ return scrollAndFocus(direction, mTempRect.left, mTempRect.right);
+ }
+
+ /**
+ * <p>Handles scrolling in response to a "home/end" shortcut press. This
+ * method will scroll the view to the left or right and give the focus
+ * to the leftmost/rightmost 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_LEFT}
+ * to go the left of the view or {@link android.view.View#FOCUS_RIGHT}
+ * to go the right
+ * @return true if the key event is consumed by this method, false otherwise
+ */
+ public boolean fullScroll(int direction) {
+ boolean right = direction == View.FOCUS_RIGHT;
+ int width = getWidth();
+
+ mTempRect.left = 0;
+ mTempRect.right = width;
+
+ if (right) {
+ int count = getChildCount();
+ if (count > 0) {
+ View view = getChildAt(0);
+ mTempRect.right = view.getRight();
+ mTempRect.left = mTempRect.right - width;
+ }
+ }
+
+ return scrollAndFocus(direction, mTempRect.left, mTempRect.right);
+ }
+
+ /**
+ * <p>Scrolls the view to make the area defined by <code>left</code> and
+ * <code>right</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_LEFT}
+ * to go left {@link android.view.View#FOCUS_RIGHT} to right
+ * @param left the left offset of the new area to be made visible
+ * @param right the right 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 left, int right) {
+ boolean handled = true;
+
+ int width = getWidth();
+ int containerLeft = getScrollX();
+ int containerRight = containerLeft + width;
+ boolean goLeft = direction == View.FOCUS_LEFT;
+
+ View newFocused = findFocusableViewInBounds(goLeft, left, right);
+ if (newFocused == null) {
+ newFocused = this;
+ }
+
+ if (left >= containerLeft && right <= containerRight) {
+ handled = false;
+ } else {
+ int delta = goLeft ? (left - containerLeft) : (right - containerRight);
+ doScrollX(delta);
+ }
+
+ if (newFocused != findFocus()) newFocused.requestFocus(direction);
+
+ return handled;
+ }
+
+ /**
+ * Handle scrolling in response to a left or right 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)) {
+ nextFocused.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(nextFocused, mTempRect);
+ int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+ doScrollX(scrollDelta);
+ nextFocused.requestFocus(direction);
+ } else {
+ // no new focus
+ int scrollDelta = maxJump;
+
+ if (direction == View.FOCUS_LEFT && getScrollX() < scrollDelta) {
+ scrollDelta = getScrollX();
+ } else if (direction == View.FOCUS_RIGHT && getChildCount() > 0) {
+
+ int daRight = getChildAt(0).getRight();
+
+ int screenRight = getScrollX() + getWidth();
+
+ if (daRight - screenRight < maxJump) {
+ scrollDelta = daRight - screenRight;
+ }
+ }
+ if (scrollDelta == 0) {
+ return false;
+ }
+ doScrollX(direction == View.FOCUS_RIGHT ? 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;
+ }
+
+ /**
+ * @return whether the descendant of this scroll view is scrolled off
+ * screen.
+ */
+ private boolean isOffScreen(View descendant) {
+ return !isWithinDeltaOfScreen(descendant, 0);
+ }
+
+ /**
+ * @return whether the descendant of this scroll view is within delta
+ * pixels of being on the screen.
+ */
+ private boolean isWithinDeltaOfScreen(View descendant, int delta) {
+ descendant.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(descendant, mTempRect);
+
+ return (mTempRect.right + delta) >= getScrollX()
+ && (mTempRect.left - delta) <= (getScrollX() + getWidth());
+ }
+
+ /**
+ * Smooth scroll by a X delta
+ *
+ * @param delta the number of pixels to scroll by on the X axis
+ */
+ private void doScrollX(int delta) {
+ if (delta != 0) {
+ if (mSmoothScrollingEnabled) {
+ smoothScrollBy(delta, 0);
+ } 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) {
+ 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);
+ invalidate();
+ } else {
+ if (!mScroller.isFinished()) {
+ mScroller.abortAnimation();
+ }
+ 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 width of all of its
+ * children.</p>
+ */
+ @Override
+ protected int computeHorizontalScrollRange() {
+ final int count = getChildCount();
+ final int contentWidth = getWidth() - mPaddingLeft - mPaddingRight;
+ if (count == 0) {
+ return contentWidth;
+ }
+
+ int scrollRange = getChildAt(0).getRight();
+ final int scrollX = mScrollX;
+ final int overscrollRight = Math.max(0, scrollRange - contentWidth);
+ if (scrollX < 0) {
+ scrollRange -= scrollX;
+ } else if (scrollX > overscrollRight) {
+ scrollRange += scrollX - overscrollRight;
+ }
+
+ return scrollRange;
+ }
+
+ @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;
+
+ childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ + mPaddingBottom, lp.height);
+
+ childWidthMeasureSpec = 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();
+
+ final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
+ mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
+ + heightUsed, lp.height);
+ final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
+ lp.leftMargin + lp.rightMargin, 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) {
+ overScrollBy(x - oldX, y - oldY, oldX, oldY, getScrollRange(), 0,
+ mOverflingDistance, 0, false);
+ onScrollChanged(mScrollX, mScrollY, oldX, oldY);
+
+ final int range = getScrollRange();
+ final int overscrollMode = getOverScrollMode();
+ if (overscrollMode == OVER_SCROLL_ALWAYS ||
+ (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0)) {
+ if (x < 0 && oldX >= 0) {
+ mEdgeGlowLeft.onAbsorb((int) mScroller.getCurrVelocity());
+ } else if (x > range && oldX <= range) {
+ mEdgeGlowRight.onAbsorb((int) mScroller.getCurrVelocity());
+ }
+ }
+ }
+ awakenScrollBars();
+
+ // Keep on drawing until the animation has finished.
+ postInvalidate();
+ }
+ }
+
+ /**
+ * 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);
+
+ int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+
+ if (scrollDelta != 0) {
+ scrollBy(scrollDelta, 0);
+ }
+ }
+
+ /**
+ * 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
+ */
+ protected boolean scrollToChildRect(Rect rect, boolean immediate) {
+ final int delta = computeScrollDeltaToGetChildRectOnScreen(rect);
+ final boolean scroll = delta != 0;
+ if (scroll) {
+ if (immediate) {
+ scrollBy(delta, 0);
+ } else {
+ smoothScrollBy(delta, 0);
+ }
+ }
+ return scroll;
+ }
+
+ /**
+ * Compute the amount to scroll in the X 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 (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 (direction == View.FOCUS_FORWARD) {
+ direction = View.FOCUS_RIGHT;
+ } else if (direction == View.FOCUS_BACKWARD) {
+ direction = View.FOCUS_LEFT;
+ }
+
+ 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 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;
+
+ final int maxJump = mRight - mLeft;
+
+ if (isWithinDeltaOfScreen(currentFocused, maxJump)) {
+ currentFocused.getDrawingRect(mTempRect);
+ offsetDescendantRectToMyCoords(currentFocused, mTempRect);
+ int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect);
+ doScrollX(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 velocityX The initial velocity in the X direction. Positive
+ * numbers mean that the finger/curor is moving down the screen,
+ * which means we want to scroll towards the left.
+ */
+ public void fling(int velocityX) {
+ if (getChildCount() > 0) {
+ int width = getWidth() - mPaddingRight - mPaddingLeft;
+ int right = getChildAt(0).getWidth();
+
+ mScroller.fling(mScrollX, mScrollY, velocityX, 0, 0,
+ Math.max(0, right - width), 0, 0, width/2, 0);
+
+ final boolean movingRight = velocityX > 0;
+
+ View currentFocused = findFocus();
+ View newFocused = findFocusableViewInMyBounds(movingRight,
+ mScroller.getFinalX(), currentFocused);
+
+ if (newFocused == null) {
+ newFocused = this;
+ }
+
+ if (newFocused != currentFocused) {
+ newFocused.requestFocus(movingRight ? View.FOCUS_RIGHT : View.FOCUS_LEFT);
+ }
+
+ invalidate();
+ }
+ }
+
+ /**
+ * {@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);
+ }
+ }
+ }
+
+ @Override
+ public void setOverScrollMode(int mode) {
+ if (mode != OVER_SCROLL_NEVER) {
+ if (mEdgeGlowLeft == null) {
+ Context context = getContext();
+ final Resources res = context.getResources();
+ final Drawable edge = res.getDrawable(R.drawable.overscroll_edge);
+ final Drawable glow = res.getDrawable(R.drawable.overscroll_glow);
+ mEdgeGlowLeft = new EdgeGlow(context, edge, glow);
+ mEdgeGlowRight = new EdgeGlow(context, edge, glow);
+ }
+ } else {
+ mEdgeGlowLeft = null;
+ mEdgeGlowRight = null;
+ }
+ super.setOverScrollMode(mode);
+ }
+
+ @SuppressWarnings({"SuspiciousNameCombination"})
+ @Override
+ public void draw(Canvas canvas) {
+ super.draw(canvas);
+ if (mEdgeGlowLeft != null) {
+ final int scrollX = mScrollX;
+ if (!mEdgeGlowLeft.isFinished()) {
+ final int restoreCount = canvas.save();
+ final int height = getHeight() - mPaddingTop - mPaddingBottom;
+
+ canvas.rotate(270);
+ canvas.translate(-height + mPaddingTop, Math.min(0, scrollX));
+ mEdgeGlowLeft.setSize(height, getWidth());
+ if (mEdgeGlowLeft.draw(canvas)) {
+ invalidate();
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+ if (!mEdgeGlowRight.isFinished()) {
+ final int restoreCount = canvas.save();
+ final int width = getWidth();
+ final int height = getHeight() - mPaddingTop - mPaddingBottom;
+
+ canvas.rotate(90);
+ canvas.translate(-mPaddingTop,
+ -(Math.max(getScrollRange(), scrollX) + width));
+ mEdgeGlowRight.setSize(height, width);
+ if (mEdgeGlowRight.draw(canvas)) {
+ invalidate();
+ }
+ canvas.restoreToCount(restoreCount);
+ }
+ }
+ }
+
+ private int clamp(int n, int my, int child) {
+ if (my >= child || n < 0) {
+ return 0;
+ }
+ if ((my + n) > child) {
+ return child - my;
+ }
+ return n;
+ }
+}
diff --git a/src/com/android/browser/view/TabHolderView.java b/src/com/android/browser/view/TabHolderView.java
deleted file mode 100644
index c5a2b32..0000000
--- a/src/com/android/browser/view/TabHolderView.java
+++ /dev/null
@@ -1,52 +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.content.Context;
-import android.util.AttributeSet;
-import android.widget.LinearLayout;
-
-public class TabHolderView extends LinearLayout {
-
- /**
- * @param context
- * @param attrs
- * @param defStyle
- */
- public TabHolderView(Context context, AttributeSet attrs, int defStyle) {
- super(context, attrs, defStyle);
- }
-
- /**
- * @param context
- * @param attrs
- */
- public TabHolderView(Context context, AttributeSet attrs) {
- super(context, attrs);
- }
-
- /**
- * @param context
- */
- public TabHolderView(Context context) {
- super(context);
- }
-
- @Override
- public void setPressed(boolean p) {}
-
-}