src/com/android/contacts/ScrollingTabWidget.java - platform/packages/apps/Contacts - Git at Google

 /*
  * 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.contacts;

 import android.content.Context;
 import android.graphics.Canvas;
 import android.util.AttributeSet;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.View.OnClickListener;
 import android.view.View.OnFocusChangeListener;
 import android.widget.HorizontalScrollView;
 import android.widget.ImageView;
 import android.widget.RelativeLayout;

 /*
  * Tab widget that can contain more tabs than can fit on screen at once and scroll over them.
  */
 public class ScrollingTabWidget extends RelativeLayout
         implements OnClickListener, ViewTreeObserver.OnGlobalFocusChangeListener,
         OnFocusChangeListener {

     private static final String TAG = "ScrollingTabWidget";

     private OnTabSelectionChangedListener mSelectionChangedListener;
     private int mSelectedTab = 0;
     private ImageView mLeftArrowView;
     private ImageView mRightArrowView;
     private HorizontalScrollView mTabsScrollWrapper;
     private TabStripView mTabsView;
     private LayoutInflater mInflater;

     // Keeps track of the left most visible tab.
     private int mLeftMostVisibleTabIndex = 0;

     public ScrollingTabWidget(Context context) {
         this(context, null);
     }

     public ScrollingTabWidget(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public ScrollingTabWidget(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs);

         mInflater = (LayoutInflater) mContext.getSystemService(
                 Context.LAYOUT_INFLATER_SERVICE);

         setFocusable(true);
         setOnFocusChangeListener(this);
         if (!hasFocus()) {
             setDescendantFocusability(FOCUS_BLOCK_DESCENDANTS);
         }

         mLeftArrowView = (ImageView) mInflater.inflate(R.layout.tab_left_arrow, this, false);
         mLeftArrowView.setOnClickListener(this);
         mRightArrowView = (ImageView) mInflater.inflate(R.layout.tab_right_arrow, this, false);
         mRightArrowView.setOnClickListener(this);
         mTabsScrollWrapper = (HorizontalScrollView) mInflater.inflate(
                 R.layout.tab_layout, this, false);
         mTabsView = (TabStripView) mTabsScrollWrapper.findViewById(android.R.id.tabs);
         View accountNameView = mInflater.inflate(R.layout.tab_account_name, this, false);

         mLeftArrowView.setVisibility(View.INVISIBLE);
         mRightArrowView.setVisibility(View.INVISIBLE);

         addView(mTabsScrollWrapper);
         addView(mLeftArrowView);
         addView(mRightArrowView);
         addView(accountNameView);
     }

     @Override
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         final ViewTreeObserver treeObserver = getViewTreeObserver();
         if (treeObserver != null) {
             treeObserver.addOnGlobalFocusChangeListener(this);
         }
     }

     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
         final ViewTreeObserver treeObserver = getViewTreeObserver();
         if (treeObserver != null) {
             treeObserver.removeOnGlobalFocusChangeListener(this);
         }
     }

     protected void updateArrowVisibility() {
         int scrollViewLeftEdge = mTabsScrollWrapper.getScrollX();
         int tabsViewLeftEdge = mTabsView.getLeft();
         int scrollViewRightEdge = scrollViewLeftEdge + mTabsScrollWrapper.getWidth();
         int tabsViewRightEdge = mTabsView.getRight();

         int rightArrowCurrentVisibility = mRightArrowView.getVisibility();
         if (scrollViewRightEdge == tabsViewRightEdge
                 && rightArrowCurrentVisibility == View.VISIBLE) {
             mRightArrowView.setVisibility(View.INVISIBLE);
         } else if (scrollViewRightEdge < tabsViewRightEdge
                 && rightArrowCurrentVisibility != View.VISIBLE) {
             mRightArrowView.setVisibility(View.VISIBLE);
         }

         int leftArrowCurrentVisibility = mLeftArrowView.getVisibility();
         if (scrollViewLeftEdge == tabsViewLeftEdge
                 && leftArrowCurrentVisibility == View.VISIBLE) {
             mLeftArrowView.setVisibility(View.INVISIBLE);
         } else if (scrollViewLeftEdge > tabsViewLeftEdge
                 && leftArrowCurrentVisibility != View.VISIBLE) {
             mLeftArrowView.setVisibility(View.VISIBLE);
         }
     }

     /**
      * Returns the tab indicator view at the given index.
      *
      * @param index the zero-based index of the tab indicator view to return
      * @return the tab indicator view at the given index
      */
     public View getChildTabViewAt(int index) {
         return mTabsView.getChildAt(index);
     }

     /**
      * Returns the number of tab indicator views.
      *
      * @return the number of tab indicator views.
      */
     public int getTabCount() {
         return mTabsView.getChildCount();
     }

     /**
      * Returns the {@link ViewGroup} that actually contains the tabs. This is where the tab
      * views should be attached to when being inflated.
      */
     public ViewGroup getTabParent() {
         return mTabsView;
     }

     public void removeAllTabs() {
         mTabsView.removeAllViews();
     }

     @Override
     public void dispatchDraw(Canvas canvas) {
         updateArrowVisibility();
         super.dispatchDraw(canvas);
     }

     /**
      * Sets the current tab.
      * This method is used to bring a tab to the front of the Widget,
      * and is used to post to the rest of the UI that a different tab
      * has been brought to the foreground.
      *
      * Note, this is separate from the traditional "focus" that is
      * employed from the view logic.
      *
      * For instance, if we have a list in a tabbed view, a user may be
      * navigating up and down the list, moving the UI focus (orange
      * highlighting) through the list items.  The cursor movement does
      * not effect the "selected" tab though, because what is being
      * scrolled through is all on the same tab.  The selected tab only
      * changes when we navigate between tabs (moving from the list view
      * to the next tabbed view, in this example).
      *
      * To move both the focus AND the selected tab at once, please use
      * {@link #focusCurrentTab}. Normally, the view logic takes care of
      * adjusting the focus, so unless you're circumventing the UI,
      * you'll probably just focus your interest here.
      *
      *  @param index The tab that you want to indicate as the selected
      *  tab (tab brought to the front of the widget)
      *
      *  @see #focusCurrentTab
      */
     public void setCurrentTab(int index) {
         if (index < 0 || index >= getTabCount()) {
             return;
         }

         if (mSelectedTab < getTabCount()) {
             mTabsView.setSelected(mSelectedTab, false);
         }
         mSelectedTab = index;
         mTabsView.setSelected(mSelectedTab, true);
     }

     /**
      * Return index of the currently selected tab.
      */
     public int getCurrentTab() {
         return mSelectedTab;
     }

     /**
      * Sets the current tab and focuses the UI on it.
      * This method makes sure that the focused tab matches the selected
      * tab, normally at {@link #setCurrentTab}.  Normally this would not
      * be an issue if we go through the UI, since the UI is responsible
      * for calling TabWidget.onFocusChanged(), but in the case where we
      * are selecting the tab programmatically, we'll need to make sure
      * focus keeps up.
      *
      *  @param index The tab that you want focused (highlighted in orange)
      *  and selected (tab brought to the front of the widget)
      *
      *  @see #setCurrentTab
      */
     public void focusCurrentTab(int index) {
         if (index < 0 || index >= getTabCount()) {
             return;
         }

         setCurrentTab(index);
         getChildTabViewAt(index).requestFocus();

     }

     /**
      * Adds a tab to the list of tabs. The tab's indicator view is specified
      * by a layout id. InflateException will be thrown if there is a problem
      * inflating.
      *
      * @param layoutResId The layout id to be inflated to make the tab indicator.
      */
     public void addTab(int layoutResId) {
         addTab(mInflater.inflate(layoutResId, mTabsView, false));
     }

     /**
      * Adds a tab to the list of tabs. The tab's indicator view must be provided.
      *
      * @param child
      */
     public void addTab(View child) {
         if (child == null) {
             return;
         }

         if (child.getLayoutParams() == null) {
             final LayoutParams lp = new LayoutParams(
                     ViewGroup.LayoutParams.WRAP_CONTENT,
                     ViewGroup.LayoutParams.WRAP_CONTENT);
             lp.setMargins(0, 0, 0, 0);
             child.setLayoutParams(lp);
         }

         // Ensure you can navigate to the tab with the keyboard, and you can touch it
         child.setFocusable(true);
         child.setClickable(true);
         child.setOnClickListener(new TabClickListener());
         child.setOnFocusChangeListener(this);

         mTabsView.addView(child);
     }

     /**
      * Provides a way for ViewContactActivity and EditContactActivity to be notified that the
      * user clicked on a tab indicator.
      */
     public void setTabSelectionListener(OnTabSelectionChangedListener listener) {
         mSelectionChangedListener = listener;
     }

     public void onGlobalFocusChanged(View oldFocus, View newFocus) {
         if (isTab(oldFocus) && !isTab(newFocus)) {
             onLoseFocus();
         }
     }

     public void onFocusChange(View v, boolean hasFocus) {
         if (v == this && hasFocus) {
             onObtainFocus();
             return;
         }

         if (hasFocus) {
             for (int i = 0; i < getTabCount(); i++) {
                 if (getChildTabViewAt(i) == v) {
                     setCurrentTab(i);
                     mSelectionChangedListener.onTabSelectionChanged(i, false);
                     break;
                 }
             }
         }
     }

     /**
      * Called when the {@link ScrollingTabWidget} gets focus. Here the
      * widget decides which of it's tabs should have focus.
      */
     protected void onObtainFocus() {
         // Setting this flag, allows the children of this View to obtain focus.
         setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
         // Assign focus to the last selected tab.
         focusCurrentTab(mSelectedTab);
         mSelectionChangedListener.onTabSelectionChanged(mSelectedTab, false);
     }

     /**
      * Called when the focus has left the {@link ScrollingTabWidget} or its
      * descendants. At this time we want the children of this view to be marked
      * as un-focusable, so that next time focus is moved to the widget, the widget
      * gets control, and can assign focus where it wants.
      */
     protected void onLoseFocus() {
         // Setting this flag will effectively make the tabs unfocusable. This will
         // be toggled when the widget obtains focus again.
         setDescendantFocusability(FOCUS_BLOCK_DESCENDANTS);
     }

     public boolean isTab(View v) {
         for (int i = 0; i < getTabCount(); i++) {
             if (getChildTabViewAt(i) == v) {
                 return true;
             }
         }
         return false;
     }

     private class TabClickListener implements OnClickListener {
         public void onClick(View v) {
             for (int i = 0; i < getTabCount(); i++) {
                 if (getChildTabViewAt(i) == v) {
                     setCurrentTab(i);
                     mSelectionChangedListener.onTabSelectionChanged(i, true);
                     break;
                 }
             }
         }
     }

     public interface OnTabSelectionChangedListener {
         /**
          * Informs the tab widget host which tab was selected. It also indicates
          * if the tab was clicked/pressed or just focused into.
          *
          * @param tabIndex index of the tab that was selected
          * @param clicked whether the selection changed due to a touch/click
          * or due to focus entering the tab through navigation. Pass true
          * if it was due to a press/click and false otherwise.
          */
         void onTabSelectionChanged(int tabIndex, boolean clicked);
     }

     public void onClick(View v) {
         updateLeftMostVisible();
         if (v == mRightArrowView && (mLeftMostVisibleTabIndex + 1 < getTabCount())) {
             tabScroll(true /* right */);
         } else if (v == mLeftArrowView && mLeftMostVisibleTabIndex > 0) {
             tabScroll(false /* left */);
         }
     }

     /*
      * Updates our record of the left most visible tab. We keep track of this explicitly
      * on arrow clicks, but need to re-calibrate after focus navigation.
      */
     protected void updateLeftMostVisible() {
         int viewableLeftEdge = mTabsScrollWrapper.getScrollX();

         if (mLeftArrowView.getVisibility() == View.VISIBLE) {
             viewableLeftEdge += mLeftArrowView.getWidth();
         }

         for (int i = 0; i < getTabCount(); i++) {
             View tab = getChildTabViewAt(i);
             int tabLeftEdge = tab.getLeft();
             if (tabLeftEdge >= viewableLeftEdge) {
                 mLeftMostVisibleTabIndex = i;
                 break;
             }
         }
     }

     /**
      * Scrolls the tabs by exactly one tab width.
      *
      * @param directionRight if true, scroll to the right, if false, scroll to the left.
      */
     protected void tabScroll(boolean directionRight) {
         int scrollWidth = 0;
         View newLeftMostVisibleTab = null;
         if (directionRight) {
             newLeftMostVisibleTab = getChildTabViewAt(++mLeftMostVisibleTabIndex);
         } else {
             newLeftMostVisibleTab = getChildTabViewAt(--mLeftMostVisibleTabIndex);
         }

         scrollWidth = newLeftMostVisibleTab.getLeft() - mTabsScrollWrapper.getScrollX();
         if (mLeftMostVisibleTabIndex > 0) {
             scrollWidth -= mLeftArrowView.getWidth();
         }
         mTabsScrollWrapper.smoothScrollBy(scrollWidth, 0);
     }

 }
	/*
	* 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.contacts;

	import android.content.Context;
	import android.graphics.Canvas;
	import android.util.AttributeSet;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.ViewTreeObserver;
	import android.view.View.OnClickListener;
	import android.view.View.OnFocusChangeListener;
	import android.widget.HorizontalScrollView;
	import android.widget.ImageView;
	import android.widget.RelativeLayout;

	/*
	* Tab widget that can contain more tabs than can fit on screen at once and scroll over them.
	*/
	public class ScrollingTabWidget extends RelativeLayout
	implements OnClickListener, ViewTreeObserver.OnGlobalFocusChangeListener,
	OnFocusChangeListener {

	private static final String TAG = "ScrollingTabWidget";

	private OnTabSelectionChangedListener mSelectionChangedListener;
	private int mSelectedTab = 0;
	private ImageView mLeftArrowView;
	private ImageView mRightArrowView;
	private HorizontalScrollView mTabsScrollWrapper;
	private TabStripView mTabsView;
	private LayoutInflater mInflater;

	// Keeps track of the left most visible tab.
	private int mLeftMostVisibleTabIndex = 0;

	public ScrollingTabWidget(Context context) {
	this(context, null);
	}

	public ScrollingTabWidget(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public ScrollingTabWidget(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs);

	mInflater = (LayoutInflater) mContext.getSystemService(
	Context.LAYOUT_INFLATER_SERVICE);

	setFocusable(true);
	setOnFocusChangeListener(this);
	if (!hasFocus()) {
	setDescendantFocusability(FOCUS_BLOCK_DESCENDANTS);
	}

	mLeftArrowView = (ImageView) mInflater.inflate(R.layout.tab_left_arrow, this, false);
	mLeftArrowView.setOnClickListener(this);
	mRightArrowView = (ImageView) mInflater.inflate(R.layout.tab_right_arrow, this, false);
	mRightArrowView.setOnClickListener(this);
	mTabsScrollWrapper = (HorizontalScrollView) mInflater.inflate(
	R.layout.tab_layout, this, false);
	mTabsView = (TabStripView) mTabsScrollWrapper.findViewById(android.R.id.tabs);
	View accountNameView = mInflater.inflate(R.layout.tab_account_name, this, false);

	mLeftArrowView.setVisibility(View.INVISIBLE);
	mRightArrowView.setVisibility(View.INVISIBLE);

	addView(mTabsScrollWrapper);
	addView(mLeftArrowView);
	addView(mRightArrowView);
	addView(accountNameView);
	}

	@Override
	protected void onAttachedToWindow() {
	super.onAttachedToWindow();
	final ViewTreeObserver treeObserver = getViewTreeObserver();
	if (treeObserver != null) {
	treeObserver.addOnGlobalFocusChangeListener(this);
	}
	}

	@Override
	protected void onDetachedFromWindow() {
	super.onDetachedFromWindow();
	final ViewTreeObserver treeObserver = getViewTreeObserver();
	if (treeObserver != null) {
	treeObserver.removeOnGlobalFocusChangeListener(this);
	}
	}

	protected void updateArrowVisibility() {
	int scrollViewLeftEdge = mTabsScrollWrapper.getScrollX();
	int tabsViewLeftEdge = mTabsView.getLeft();
	int scrollViewRightEdge = scrollViewLeftEdge + mTabsScrollWrapper.getWidth();
	int tabsViewRightEdge = mTabsView.getRight();

	int rightArrowCurrentVisibility = mRightArrowView.getVisibility();
	if (scrollViewRightEdge == tabsViewRightEdge
	&& rightArrowCurrentVisibility == View.VISIBLE) {
	mRightArrowView.setVisibility(View.INVISIBLE);
	} else if (scrollViewRightEdge < tabsViewRightEdge
	&& rightArrowCurrentVisibility != View.VISIBLE) {
	mRightArrowView.setVisibility(View.VISIBLE);
	}

	int leftArrowCurrentVisibility = mLeftArrowView.getVisibility();
	if (scrollViewLeftEdge == tabsViewLeftEdge
	&& leftArrowCurrentVisibility == View.VISIBLE) {
	mLeftArrowView.setVisibility(View.INVISIBLE);
	} else if (scrollViewLeftEdge > tabsViewLeftEdge
	&& leftArrowCurrentVisibility != View.VISIBLE) {
	mLeftArrowView.setVisibility(View.VISIBLE);
	}
	}

	/**
	* Returns the tab indicator view at the given index.
	*
	* @param index the zero-based index of the tab indicator view to return
	* @return the tab indicator view at the given index
	*/
	public View getChildTabViewAt(int index) {
	return mTabsView.getChildAt(index);
	}

	/**
	* Returns the number of tab indicator views.
	*
	* @return the number of tab indicator views.
	*/
	public int getTabCount() {
	return mTabsView.getChildCount();
	}

	/**
	* Returns the {@link ViewGroup} that actually contains the tabs. This is where the tab
	* views should be attached to when being inflated.
	*/
	public ViewGroup getTabParent() {
	return mTabsView;
	}

	public void removeAllTabs() {
	mTabsView.removeAllViews();
	}

	@Override
	public void dispatchDraw(Canvas canvas) {
	updateArrowVisibility();
	super.dispatchDraw(canvas);
	}

	/**
	* Sets the current tab.
	* This method is used to bring a tab to the front of the Widget,
	* and is used to post to the rest of the UI that a different tab
	* has been brought to the foreground.
	*
	* Note, this is separate from the traditional "focus" that is
	* employed from the view logic.
	*
	* For instance, if we have a list in a tabbed view, a user may be
	* navigating up and down the list, moving the UI focus (orange
	* highlighting) through the list items. The cursor movement does
	* not effect the "selected" tab though, because what is being
	* scrolled through is all on the same tab. The selected tab only
	* changes when we navigate between tabs (moving from the list view
	* to the next tabbed view, in this example).
	*
	* To move both the focus AND the selected tab at once, please use
	* {@link #focusCurrentTab}. Normally, the view logic takes care of
	* adjusting the focus, so unless you're circumventing the UI,
	* you'll probably just focus your interest here.
	*
	* @param index The tab that you want to indicate as the selected
	* tab (tab brought to the front of the widget)
	*
	* @see #focusCurrentTab
	*/
	public void setCurrentTab(int index) {
	if (index < 0 \|\| index >= getTabCount()) {
	return;
	}

	if (mSelectedTab < getTabCount()) {
	mTabsView.setSelected(mSelectedTab, false);
	}
	mSelectedTab = index;
	mTabsView.setSelected(mSelectedTab, true);
	}

	/**
	* Return index of the currently selected tab.
	*/
	public int getCurrentTab() {
	return mSelectedTab;
	}

	/**
	* Sets the current tab and focuses the UI on it.
	* This method makes sure that the focused tab matches the selected
	* tab, normally at {@link #setCurrentTab}. Normally this would not
	* be an issue if we go through the UI, since the UI is responsible
	* for calling TabWidget.onFocusChanged(), but in the case where we
	* are selecting the tab programmatically, we'll need to make sure
	* focus keeps up.
	*
	* @param index The tab that you want focused (highlighted in orange)
	* and selected (tab brought to the front of the widget)
	*
	* @see #setCurrentTab
	*/
	public void focusCurrentTab(int index) {
	if (index < 0 \|\| index >= getTabCount()) {
	return;
	}

	setCurrentTab(index);
	getChildTabViewAt(index).requestFocus();

	}

	/**
	* Adds a tab to the list of tabs. The tab's indicator view is specified
	* by a layout id. InflateException will be thrown if there is a problem
	* inflating.
	*
	* @param layoutResId The layout id to be inflated to make the tab indicator.
	*/
	public void addTab(int layoutResId) {
	addTab(mInflater.inflate(layoutResId, mTabsView, false));
	}

	/**
	* Adds a tab to the list of tabs. The tab's indicator view must be provided.
	*
	* @param child
	*/
	public void addTab(View child) {
	if (child == null) {
	return;
	}

	if (child.getLayoutParams() == null) {
	final LayoutParams lp = new LayoutParams(
	ViewGroup.LayoutParams.WRAP_CONTENT,
	ViewGroup.LayoutParams.WRAP_CONTENT);
	lp.setMargins(0, 0, 0, 0);
	child.setLayoutParams(lp);
	}

	// Ensure you can navigate to the tab with the keyboard, and you can touch it
	child.setFocusable(true);
	child.setClickable(true);
	child.setOnClickListener(new TabClickListener());
	child.setOnFocusChangeListener(this);

	mTabsView.addView(child);
	}

	/**
	* Provides a way for ViewContactActivity and EditContactActivity to be notified that the
	* user clicked on a tab indicator.
	*/
	public void setTabSelectionListener(OnTabSelectionChangedListener listener) {
	mSelectionChangedListener = listener;
	}

	public void onGlobalFocusChanged(View oldFocus, View newFocus) {
	if (isTab(oldFocus) && !isTab(newFocus)) {
	onLoseFocus();
	}
	}

	public void onFocusChange(View v, boolean hasFocus) {
	if (v == this && hasFocus) {
	onObtainFocus();
	return;
	}

	if (hasFocus) {
	for (int i = 0; i < getTabCount(); i++) {
	if (getChildTabViewAt(i) == v) {
	setCurrentTab(i);
	mSelectionChangedListener.onTabSelectionChanged(i, false);
	break;
	}
	}
	}
	}

	/**
	* Called when the {@link ScrollingTabWidget} gets focus. Here the
	* widget decides which of it's tabs should have focus.
	*/
	protected void onObtainFocus() {
	// Setting this flag, allows the children of this View to obtain focus.
	setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
	// Assign focus to the last selected tab.
	focusCurrentTab(mSelectedTab);
	mSelectionChangedListener.onTabSelectionChanged(mSelectedTab, false);
	}

	/**
	* Called when the focus has left the {@link ScrollingTabWidget} or its
	* descendants. At this time we want the children of this view to be marked
	* as un-focusable, so that next time focus is moved to the widget, the widget
	* gets control, and can assign focus where it wants.
	*/
	protected void onLoseFocus() {
	// Setting this flag will effectively make the tabs unfocusable. This will
	// be toggled when the widget obtains focus again.
	setDescendantFocusability(FOCUS_BLOCK_DESCENDANTS);
	}

	public boolean isTab(View v) {
	for (int i = 0; i < getTabCount(); i++) {
	if (getChildTabViewAt(i) == v) {
	return true;
	}
	}
	return false;
	}

	private class TabClickListener implements OnClickListener {
	public void onClick(View v) {
	for (int i = 0; i < getTabCount(); i++) {
	if (getChildTabViewAt(i) == v) {
	setCurrentTab(i);
	mSelectionChangedListener.onTabSelectionChanged(i, true);
	break;
	}
	}
	}
	}

	public interface OnTabSelectionChangedListener {
	/**
	* Informs the tab widget host which tab was selected. It also indicates
	* if the tab was clicked/pressed or just focused into.
	*
	* @param tabIndex index of the tab that was selected
	* @param clicked whether the selection changed due to a touch/click
	* or due to focus entering the tab through navigation. Pass true
	* if it was due to a press/click and false otherwise.
	*/
	void onTabSelectionChanged(int tabIndex, boolean clicked);
	}

	public void onClick(View v) {
	updateLeftMostVisible();
	if (v == mRightArrowView && (mLeftMostVisibleTabIndex + 1 < getTabCount())) {
	tabScroll(true /* right */);
	} else if (v == mLeftArrowView && mLeftMostVisibleTabIndex > 0) {
	tabScroll(false /* left */);
	}
	}

	/*
	* Updates our record of the left most visible tab. We keep track of this explicitly
	* on arrow clicks, but need to re-calibrate after focus navigation.
	*/
	protected void updateLeftMostVisible() {
	int viewableLeftEdge = mTabsScrollWrapper.getScrollX();

	if (mLeftArrowView.getVisibility() == View.VISIBLE) {
	viewableLeftEdge += mLeftArrowView.getWidth();
	}

	for (int i = 0; i < getTabCount(); i++) {
	View tab = getChildTabViewAt(i);
	int tabLeftEdge = tab.getLeft();
	if (tabLeftEdge >= viewableLeftEdge) {
	mLeftMostVisibleTabIndex = i;
	break;
	}
	}
	}

	/**
	* Scrolls the tabs by exactly one tab width.
	*
	* @param directionRight if true, scroll to the right, if false, scroll to the left.
	*/
	protected void tabScroll(boolean directionRight) {
	int scrollWidth = 0;
	View newLeftMostVisibleTab = null;
	if (directionRight) {
	newLeftMostVisibleTab = getChildTabViewAt(++mLeftMostVisibleTabIndex);
	} else {
	newLeftMostVisibleTab = getChildTabViewAt(--mLeftMostVisibleTabIndex);
	}

	scrollWidth = newLeftMostVisibleTab.getLeft() - mTabsScrollWrapper.getScrollX();
	if (mLeftMostVisibleTabIndex > 0) {
	scrollWidth -= mLeftArrowView.getWidth();
	}
	mTabsScrollWrapper.smoothScrollBy(scrollWidth, 0);
	}

	}