/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.widget;
import android.annotation.DrawableRes;
import android.annotation.Nullable;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.PointerIcon;
import android.view.View;
import android.view.View.OnFocusChangeListener;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import com.android.internal.R;
Displays a list of tab labels representing each page in the parent's tab
collection.
The container object for this widget is TabHost
. When the user selects a tab, this object sends a message to the parent container, TabHost, to tell it to switch the displayed page. You typically won't use many methods directly on this object. The container TabHost is used to add labels, add the callback handler, and manage callbacks. You might call this object to iterate the list of tabs, or to tweak the layout of the tab list, but most methods should be called on the containing TabHost object.
@attr ref android.R.styleable#TabWidget_divider @attr ref android.R.styleable#TabWidget_tabStripEnabled @attr ref android.R.styleable#TabWidget_tabStripLeft @attr ref android.R.styleable#TabWidget_tabStripRight
/**
*
* Displays a list of tab labels representing each page in the parent's tab
* collection.
* <p>
* The container object for this widget is {@link android.widget.TabHost TabHost}.
* When the user selects a tab, this object sends a message to the parent
* container, TabHost, to tell it to switch the displayed page. You typically
* won't use many methods directly on this object. The container TabHost is
* used to add labels, add the callback handler, and manage callbacks. You
* might call this object to iterate the list of tabs, or to tweak the layout
* of the tab list, but most methods should be called on the containing TabHost
* object.
*
* @attr ref android.R.styleable#TabWidget_divider
* @attr ref android.R.styleable#TabWidget_tabStripEnabled
* @attr ref android.R.styleable#TabWidget_tabStripLeft
* @attr ref android.R.styleable#TabWidget_tabStripRight
*/
public class TabWidget extends LinearLayout implements OnFocusChangeListener {
private final Rect mBounds = new Rect();
private OnTabSelectionChanged mSelectionChangedListener;
// This value will be set to 0 as soon as the first tab is added to TabHost.
private int mSelectedTab = -1;
@Nullable
private Drawable mLeftStrip;
@Nullable
private Drawable mRightStrip;
private boolean mDrawBottomStrips = true;
private boolean mStripMoved;
// When positive, the widths and heights of tabs will be imposed so that
// they fit in parent.
private int mImposedTabsHeight = -1;
private int[] mImposedTabWidths;
public TabWidget(Context context) {
this(context, null);
}
public TabWidget(Context context, AttributeSet attrs) {
this(context, attrs, com.android.internal.R.attr.tabWidgetStyle);
}
public TabWidget(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public TabWidget(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
final TypedArray a = context.obtainStyledAttributes(
attrs, R.styleable.TabWidget, defStyleAttr, defStyleRes);
mDrawBottomStrips = a.getBoolean(R.styleable.TabWidget_tabStripEnabled, mDrawBottomStrips);
// Tests the target SDK version, as set in the Manifest. Could not be
// set using styles.xml in a values-v? directory which targets the
// current platform SDK version instead.
final boolean isTargetSdkDonutOrLower =
context.getApplicationInfo().targetSdkVersion <= Build.VERSION_CODES.DONUT;
final boolean hasExplicitLeft = a.hasValueOrEmpty(R.styleable.TabWidget_tabStripLeft);
if (hasExplicitLeft) {
mLeftStrip = a.getDrawable(R.styleable.TabWidget_tabStripLeft);
} else if (isTargetSdkDonutOrLower) {
mLeftStrip = context.getDrawable(R.drawable.tab_bottom_left_v4);
} else {
mLeftStrip = context.getDrawable(R.drawable.tab_bottom_left);
}
final boolean hasExplicitRight = a.hasValueOrEmpty(R.styleable.TabWidget_tabStripRight);
if (hasExplicitRight) {
mRightStrip = a.getDrawable(R.styleable.TabWidget_tabStripRight);
} else if (isTargetSdkDonutOrLower) {
mRightStrip = context.getDrawable(R.drawable.tab_bottom_right_v4);
} else {
mRightStrip = context.getDrawable(R.drawable.tab_bottom_right);
}
a.recycle();
setChildrenDrawingOrderEnabled(true);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
mStripMoved = true;
super.onSizeChanged(w, h, oldw, oldh);
}
@Override
protected int getChildDrawingOrder(int childCount, int i) {
if (mSelectedTab == -1) {
return i;
} else {
// Always draw the selected tab last, so that drop shadows are drawn
// in the correct z-order.
if (i == childCount - 1) {
return mSelectedTab;
} else if (i >= mSelectedTab) {
return i + 1;
} else {
return i;
}
}
}
@Override
void measureChildBeforeLayout(View child, int childIndex, int widthMeasureSpec, int totalWidth,
int heightMeasureSpec, int totalHeight) {
if (!isMeasureWithLargestChildEnabled() && mImposedTabsHeight >= 0) {
widthMeasureSpec = MeasureSpec.makeMeasureSpec(
totalWidth + mImposedTabWidths[childIndex], MeasureSpec.EXACTLY);
heightMeasureSpec = MeasureSpec.makeMeasureSpec(mImposedTabsHeight,
MeasureSpec.EXACTLY);
}
super.measureChildBeforeLayout(child, childIndex,
widthMeasureSpec, totalWidth, heightMeasureSpec, totalHeight);
}
@Override
void measureHorizontal(int widthMeasureSpec, int heightMeasureSpec) {
if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.UNSPECIFIED) {
super.measureHorizontal(widthMeasureSpec, heightMeasureSpec);
return;
}
// First, measure with no constraint
final int width = MeasureSpec.getSize(widthMeasureSpec);
final int unspecifiedWidth = MeasureSpec.makeSafeMeasureSpec(width,
MeasureSpec.UNSPECIFIED);
mImposedTabsHeight = -1;
super.measureHorizontal(unspecifiedWidth, heightMeasureSpec);
int extraWidth = getMeasuredWidth() - width;
if (extraWidth > 0) {
final int count = getChildCount();
int childCount = 0;
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() == GONE) continue;
childCount++;
}
if (childCount > 0) {
if (mImposedTabWidths == null || mImposedTabWidths.length != count) {
mImposedTabWidths = new int[count];
}
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() == GONE) continue;
final int childWidth = child.getMeasuredWidth();
final int delta = extraWidth / childCount;
final int newWidth = Math.max(0, childWidth - delta);
mImposedTabWidths[i] = newWidth;
// Make sure the extra width is evenly distributed, no int division remainder
extraWidth -= childWidth - newWidth; // delta may have been clamped
childCount--;
mImposedTabsHeight = Math.max(mImposedTabsHeight, child.getMeasuredHeight());
}
}
}
// Measure again, this time with imposed tab widths and respecting
// initial spec request.
super.measureHorizontal(widthMeasureSpec, heightMeasureSpec);
}
Returns the tab indicator view at the given index.
Params: - index – the zero-based index of the tab indicator view to return
Returns: the tab indicator view at the given index
/**
* 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 getChildAt(index);
}
Returns the number of tab indicator views.
Returns: the number of tab indicator views
/**
* Returns the number of tab indicator views.
*
* @return the number of tab indicator views
*/
public int getTabCount() {
return getChildCount();
}
Sets the drawable to use as a divider between the tab indicators.
Params: - drawable – the divider drawable
@attr ref android.R.styleable#TabWidget_divider
/**
* Sets the drawable to use as a divider between the tab indicators.
*
* @param drawable the divider drawable
* @attr ref android.R.styleable#TabWidget_divider
*/
@Override
public void setDividerDrawable(@Nullable Drawable drawable) {
super.setDividerDrawable(drawable);
}
Sets the drawable to use as a divider between the tab indicators.
Params: - resId – the resource identifier of the drawable to use as a divider
@attr ref android.R.styleable#TabWidget_divider
/**
* Sets the drawable to use as a divider between the tab indicators.
*
* @param resId the resource identifier of the drawable to use as a divider
* @attr ref android.R.styleable#TabWidget_divider
*/
public void setDividerDrawable(@DrawableRes int resId) {
setDividerDrawable(mContext.getDrawable(resId));
}
Sets the drawable to use as the left part of the strip below the tab
indicators.
Params: - drawable – the left strip drawable
See Also: @attr ref android.R.styleable#TabWidget_tabStripLeft
/**
* Sets the drawable to use as the left part of the strip below the tab
* indicators.
*
* @param drawable the left strip drawable
* @see #getLeftStripDrawable()
* @attr ref android.R.styleable#TabWidget_tabStripLeft
*/
public void setLeftStripDrawable(@Nullable Drawable drawable) {
mLeftStrip = drawable;
requestLayout();
invalidate();
}
Sets the drawable to use as the left part of the strip below the tab
indicators.
Params: - resId – the resource identifier of the drawable to use as the left
strip drawable
See Also: @attr ref android.R.styleable#TabWidget_tabStripLeft
/**
* Sets the drawable to use as the left part of the strip below the tab
* indicators.
*
* @param resId the resource identifier of the drawable to use as the left
* strip drawable
* @see #getLeftStripDrawable()
* @attr ref android.R.styleable#TabWidget_tabStripLeft
*/
public void setLeftStripDrawable(@DrawableRes int resId) {
setLeftStripDrawable(mContext.getDrawable(resId));
}
See Also: Returns: the drawable used as the left part of the strip below the tab indicators, may be null
@attr ref android.R.styleable#TabWidget_tabStripLeft
/**
* @return the drawable used as the left part of the strip below the tab
* indicators, may be {@code null}
* @see #setLeftStripDrawable(int)
* @see #setLeftStripDrawable(Drawable)
* @attr ref android.R.styleable#TabWidget_tabStripLeft
*/
@Nullable
public Drawable getLeftStripDrawable() {
return mLeftStrip;
}
Sets the drawable to use as the right part of the strip below the tab
indicators.
Params: - drawable – the right strip drawable
See Also: @attr ref android.R.styleable#TabWidget_tabStripRight
/**
* Sets the drawable to use as the right part of the strip below the tab
* indicators.
*
* @param drawable the right strip drawable
* @see #getRightStripDrawable()
* @attr ref android.R.styleable#TabWidget_tabStripRight
*/
public void setRightStripDrawable(@Nullable Drawable drawable) {
mRightStrip = drawable;
requestLayout();
invalidate();
}
Sets the drawable to use as the right part of the strip below the tab
indicators.
Params: - resId – the resource identifier of the drawable to use as the right
strip drawable
See Also: @attr ref android.R.styleable#TabWidget_tabStripRight
/**
* Sets the drawable to use as the right part of the strip below the tab
* indicators.
*
* @param resId the resource identifier of the drawable to use as the right
* strip drawable
* @see #getRightStripDrawable()
* @attr ref android.R.styleable#TabWidget_tabStripRight
*/
public void setRightStripDrawable(@DrawableRes int resId) {
setRightStripDrawable(mContext.getDrawable(resId));
}
See Also: Returns: the drawable used as the right part of the strip below the tab indicators, may be null
@attr ref android.R.styleable#TabWidget_tabStripRight
/**
* @return the drawable used as the right part of the strip below the tab
* indicators, may be {@code null}
* @see #setRightStripDrawable(int)
* @see #setRightStripDrawable(Drawable)
* @attr ref android.R.styleable#TabWidget_tabStripRight
*/
@Nullable
public Drawable getRightStripDrawable() {
return mRightStrip;
}
Controls whether the bottom strips on the tab indicators are drawn or
not. The default is to draw them. If the user specifies a custom
view for the tab indicators, then the TabHost class calls this method
to disable drawing of the bottom strips.
Params: - stripEnabled – true if the bottom strips should be drawn.
/**
* Controls whether the bottom strips on the tab indicators are drawn or
* not. The default is to draw them. If the user specifies a custom
* view for the tab indicators, then the TabHost class calls this method
* to disable drawing of the bottom strips.
* @param stripEnabled true if the bottom strips should be drawn.
*/
public void setStripEnabled(boolean stripEnabled) {
mDrawBottomStrips = stripEnabled;
invalidate();
}
Indicates whether the bottom strips on the tab indicators are drawn
or not.
/**
* Indicates whether the bottom strips on the tab indicators are drawn
* or not.
*/
public boolean isStripEnabled() {
return mDrawBottomStrips;
}
@Override
public void childDrawableStateChanged(View child) {
if (getTabCount() > 0 && child == getChildTabViewAt(mSelectedTab)) {
// To make sure that the bottom strip is redrawn
invalidate();
}
super.childDrawableStateChanged(child);
}
@Override
public void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
// Do nothing if there are no tabs.
if (getTabCount() == 0) return;
// If the user specified a custom view for the tab indicators, then
// do not draw the bottom strips.
if (!mDrawBottomStrips) {
// Skip drawing the bottom strips.
return;
}
final View selectedChild = getChildTabViewAt(mSelectedTab);
final Drawable leftStrip = mLeftStrip;
final Drawable rightStrip = mRightStrip;
if (leftStrip != null) {
leftStrip.setState(selectedChild.getDrawableState());
}
if (rightStrip != null) {
rightStrip.setState(selectedChild.getDrawableState());
}
if (mStripMoved) {
final Rect bounds = mBounds;
bounds.left = selectedChild.getLeft();
bounds.right = selectedChild.getRight();
final int myHeight = getHeight();
if (leftStrip != null) {
leftStrip.setBounds(Math.min(0, bounds.left - leftStrip.getIntrinsicWidth()),
myHeight - leftStrip.getIntrinsicHeight(), bounds.left, myHeight);
}
if (rightStrip != null) {
rightStrip.setBounds(bounds.right, myHeight - rightStrip.getIntrinsicHeight(),
Math.max(getWidth(), bounds.right + rightStrip.getIntrinsicWidth()),
myHeight);
}
mStripMoved = false;
}
if (leftStrip != null) {
leftStrip.draw(canvas);
}
if (rightStrip != null) {
rightStrip.draw(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 setCurrentTab
. 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.
Params: - index – the index of the tab that you want to indicate as the
selected tab (tab brought to the front of the widget)
See Also:
/**
* Sets the current tab.
* <p>
* 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.
* <p>
* Note, this is separate from the traditional "focus" that is
* employed from the view logic.
* <p>
* 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).
* <p>
* To move both the focus AND the selected tab at once, please use
* {@link #setCurrentTab}. 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 index of 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() || index == mSelectedTab) {
return;
}
if (mSelectedTab != -1) {
getChildTabViewAt(mSelectedTab).setSelected(false);
}
mSelectedTab = index;
getChildTabViewAt(mSelectedTab).setSelected(true);
mStripMoved = true;
}
@Override
public CharSequence getAccessibilityClassName() {
return TabWidget.class.getName();
}
@hide
/** @hide */
@Override
public void onInitializeAccessibilityEventInternal(AccessibilityEvent event) {
super.onInitializeAccessibilityEventInternal(event);
event.setItemCount(getTabCount());
event.setCurrentItemIndex(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 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 /**
* 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) {
final int oldTab = mSelectedTab;
// set the tab
setCurrentTab(index);
// change the focus if applicable.
if (oldTab != index) {
getChildTabViewAt(index).requestFocus();
}
}
@Override
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
final int count = getTabCount();
for (int i = 0; i < count; i++) {
final View child = getChildTabViewAt(i);
child.setEnabled(enabled);
}
}
@Override
public void addView(View child) {
if (child.getLayoutParams() == null) {
final LinearLayout.LayoutParams lp = new LayoutParams(
0, ViewGroup.LayoutParams.MATCH_PARENT, 1.0f);
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);
if (child.getPointerIcon() == null) {
child.setPointerIcon(PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_HAND));
}
super.addView(child);
// TODO: detect this via geometry with a tabwidget listener rather
// than potentially interfere with the view's listener
child.setOnClickListener(new TabClickListener(getTabCount() - 1));
}
@Override
public void removeAllViews() {
super.removeAllViews();
mSelectedTab = -1;
}
@Override
public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) {
if (!isEnabled()) {
return null;
}
return super.onResolvePointerIcon(event, pointerIndex);
}
Provides a way for TabHost
to be notified that the user clicked on a tab indicator. /**
* Provides a way for {@link TabHost} to be notified that the user clicked
* on a tab indicator.
*/
void setTabSelectionListener(OnTabSelectionChanged listener) {
mSelectionChangedListener = listener;
}
@Override
public void onFocusChange(View v, boolean hasFocus) {
// No-op. Tab selection is separate from keyboard focus.
}
// registered with each tab indicator so we can notify tab host
private class TabClickListener implements OnClickListener {
private final int mTabIndex;
private TabClickListener(int tabIndex) {
mTabIndex = tabIndex;
}
public void onClick(View v) {
mSelectionChangedListener.onTabSelectionChanged(mTabIndex, true);
}
}
Lets TabHost
know that the user clicked on a tab indicator. /**
* Lets {@link TabHost} know that the user clicked on a tab indicator.
*/
interface OnTabSelectionChanged {
Informs the TabHost which tab was selected. It also indicates
if the tab was clicked/pressed or just focused into.
Params: - tabIndex – index of the tab that was selected
- clicked – whether the selection changed due to a touch/click or due to focus entering the tab through navigation.
true
if it was due to a press/click and false
otherwise.
/**
* Informs the TabHost 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.
* {@code true} if it was due to a press/click and
* {@code false} otherwise.
*/
void onTabSelectionChanged(int tabIndex, boolean clicked);
}
}