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