/*

* Copyright (C) 2008 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.animation.Animator;

import android.animation.Animator.AnimatorListener;

import android.animation.AnimatorListenerAdapter;

import android.animation.AnimatorSet;

import android.animation.ObjectAnimator;

import android.animation.PropertyValuesHolder;

import android.annotation.StyleRes;

import android.content.Context;

import android.content.res.ColorStateList;

import android.content.res.TypedArray;

import android.graphics.Rect;

import android.graphics.drawable.Drawable;

import android.os.Build;

import android.os.SystemClock;

import android.text.TextUtils;

import android.text.TextUtils.TruncateAt;

import android.util.IntProperty;

import android.util.MathUtils;

import android.util.Property;

import android.util.TypedValue;

import android.view.Gravity;

import android.view.MotionEvent;

import android.view.View;

import android.view.View.MeasureSpec;

import android.view.ViewConfiguration;

import android.view.ViewGroup.LayoutParams;

import android.view.ViewGroupOverlay;

import android.widget.AbsListView.OnScrollListener;

import android.widget.ImageView.ScaleType;

import com.android.internal.R;

/**

* Helper class for AbsListView to draw and control the Fast Scroll thumb

*/

class FastScroller {

/** Duration of fade-out animation. */

private static final int DURATION_FADE_OUT = 300;

/** Duration of fade-in animation. */

private static final int DURATION_FADE_IN = 150;

/** Duration of transition cross-fade animation. */

private static final int DURATION_CROSS_FADE = 50;

/** Duration of transition resize animation. */

private static final int DURATION_RESIZE = 100;

/** Inactivity timeout before fading controls. */

private static final long FADE_TIMEOUT = 1500;

/** Minimum number of pages to justify showing a fast scroll thumb. */

private static final int MIN_PAGES = 4;

/** Scroll thumb and preview not showing. */

private static final int STATE_NONE = 0;

/** Scroll thumb visible and moving along with the scrollbar. */

private static final int STATE_VISIBLE = 1;

/** Scroll thumb and preview being dragged by user. */

private static final int STATE_DRAGGING = 2;

// Positions for preview image and text.

private static final int OVERLAY_FLOATING = 0;

private static final int OVERLAY_AT_THUMB = 1;

private static final int OVERLAY_ABOVE_THUMB = 2;

// Positions for thumb in relation to track.

private static final int THUMB_POSITION_MIDPOINT = 0;

private static final int THUMB_POSITION_INSIDE = 1;

// Indices for mPreviewResId.

private static final int PREVIEW_LEFT = 0;

private static final int PREVIEW_RIGHT = 1;

/** Delay before considering a tap in the thumb area to be a drag. */

private static final long TAP_TIMEOUT = ViewConfiguration.getTapTimeout();

private final Rect mTempBounds = new Rect();

private final Rect mTempMargins = new Rect();

private final Rect mContainerRect = new Rect();

private final AbsListView mList;

private final ViewGroupOverlay mOverlay;

private final TextView mPrimaryText;

private final TextView mSecondaryText;

private final ImageView mThumbImage;

private final ImageView mTrackImage;

private final View mPreviewImage;

/**

* Preview image resource IDs for left- and right-aligned layouts. See

* {@link #PREVIEW_LEFT} and {@link #PREVIEW_RIGHT}.

*/

private final int[] mPreviewResId = new int[2];

/** The minimum touch target size in pixels. */

private final int mMinimumTouchTarget;

/**

* Padding in pixels around the preview text. Applied as layout margins to

* the preview text and padding to the preview image.

*/

private int mPreviewPadding;

private int mPreviewMinWidth;

private int mPreviewMinHeight;

private int mThumbMinWidth;

private int mThumbMinHeight;

/** Theme-specified text size. Used only if text appearance is not set. */

private float mTextSize;

/** Theme-specified text color. Used only if text appearance is not set. */

private ColorStateList mTextColor;

private Drawable mThumbDrawable;

private Drawable mTrackDrawable;

private int mTextAppearance;

private int mThumbPosition;

// Used to convert between y-coordinate and thumb position within track.

private float mThumbOffset;

private float mThumbRange;

/** Total width of decorations. */

private int mWidth;

/** Set containing decoration transition animations. */

private AnimatorSet mDecorAnimation;

/** Set containing preview text transition animations. */

private AnimatorSet mPreviewAnimation;

/** Whether the primary text is showing. */

private boolean mShowingPrimary;

/** Whether we're waiting for completion of scrollTo(). */

private boolean mScrollCompleted;

/** The position of the first visible item in the list. */

private int mFirstVisibleItem;

/** The number of headers at the top of the view. */

private int mHeaderCount;

/** The index of the current section. */

private int mCurrentSection = -1;

/** The current scrollbar position. */

private int mScrollbarPosition = -1;

/** Whether the list is long enough to need a fast scroller. */

private boolean mLongList;

private Object[] mSections;

/** Whether this view is currently performing layout. */

private boolean mUpdatingLayout;

/**

* Current decoration state, one of:

* <ul>

* <li>{@link #STATE_NONE}, nothing visible

* <li>{@link #STATE_VISIBLE}, showing track and thumb

* <li>{@link #STATE_DRAGGING}, visible and showing preview

* </ul>

*/

private int mState;

/** Whether the preview image is visible. */

private boolean mShowingPreview;

private Adapter mListAdapter;

private SectionIndexer mSectionIndexer;

/** Whether decorations should be laid out from right to left. */

private boolean mLayoutFromRight;

/** Whether the fast scroller is enabled. */

private boolean mEnabled;

/** Whether the scrollbar and decorations should always be shown. */

private boolean mAlwaysShow;

/**

* Position for the preview image and text. One of:

* <ul>

* <li>{@link #OVERLAY_FLOATING}

* <li>{@link #OVERLAY_AT_THUMB}

* <li>{@link #OVERLAY_ABOVE_THUMB}

* </ul>

*/

private int mOverlayPosition;

/** Current scrollbar style, including inset and overlay properties. */

private int mScrollBarStyle;

/** Whether to precisely match the thumb position to the list. */

private boolean mMatchDragPosition;

private float mInitialTouchY;

private long mPendingDrag = -1;

private int mScaledTouchSlop;

private int mOldItemCount;

private int mOldChildCount;

/**

* Used to delay hiding fast scroll decorations.

*/

private final Runnable mDeferHide = new Runnable() {

@Override

public void run() {

setState(STATE_NONE);

}

};

/**

* Used to effect a transition from primary to secondary text.

*/

private final AnimatorListener mSwitchPrimaryListener = new AnimatorListenerAdapter() {

@Override

public void onAnimationEnd(Animator animation) {

mShowingPrimary = !mShowingPrimary;

}

};

public FastScroller(AbsListView listView, int styleResId) {

mList = listView;

mOldItemCount = listView.getCount();

mOldChildCount = listView.getChildCount();

final Context context = listView.getContext();

mScaledTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

mScrollBarStyle = listView.getScrollBarStyle();

mScrollCompleted = true;

mState = STATE_VISIBLE;

mMatchDragPosition =

context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.HONEYCOMB;

mTrackImage = new ImageView(context);

mTrackImage.setScaleType(ScaleType.FIT_XY);

mThumbImage = new ImageView(context);

mThumbImage.setScaleType(ScaleType.FIT_XY);

mPreviewImage = new View(context);

mPreviewImage.setAlpha(0f);

mPrimaryText = createPreviewTextView(context);

mSecondaryText = createPreviewTextView(context);

mMinimumTouchTarget = listView.getResources().getDimensionPixelSize(

com.android.internal.R.dimen.fast_scroller_minimum_touch_target);

setStyle(styleResId);

final ViewGroupOverlay overlay = listView.getOverlay();

mOverlay = overlay;

overlay.add(mTrackImage);

overlay.add(mThumbImage);

overlay.add(mPreviewImage);

overlay.add(mPrimaryText);

overlay.add(mSecondaryText);

getSectionsFromIndexer();

updateLongList(mOldChildCount, mOldItemCount);

setScrollbarPosition(listView.getVerticalScrollbarPosition());

postAutoHide();

}

private void updateAppearance() {

int width = 0;

// Add track to overlay if it has an image.

mTrackImage.setImageDrawable(mTrackDrawable);

if (mTrackDrawable != null) {

width = Math.max(width, mTrackDrawable.getIntrinsicWidth());

}

// Add thumb to overlay if it has an image.

mThumbImage.setImageDrawable(mThumbDrawable);

mThumbImage.setMinimumWidth(mThumbMinWidth);

mThumbImage.setMinimumHeight(mThumbMinHeight);

if (mThumbDrawable != null) {

width = Math.max(width, mThumbDrawable.getIntrinsicWidth());

}

// Account for minimum thumb width.

mWidth = Math.max(width, mThumbMinWidth);

if (mTextAppearance != 0) {

mPrimaryText.setTextAppearance(mTextAppearance);

mSecondaryText.setTextAppearance(mTextAppearance);

}

if (mTextColor != null) {

mPrimaryText.setTextColor(mTextColor);

mSecondaryText.setTextColor(mTextColor);

}

if (mTextSize > 0) {

mPrimaryText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextSize);

mSecondaryText.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextSize);

}

final int padding = mPreviewPadding;

mPrimaryText.setIncludeFontPadding(false);

mPrimaryText.setPadding(padding, padding, padding, padding);

mSecondaryText.setIncludeFontPadding(false);

mSecondaryText.setPadding(padding, padding, padding, padding);

refreshDrawablePressedState();

}

public void setStyle(@StyleRes int resId) {

final Context context = mList.getContext();

final TypedArray ta = context.obtainStyledAttributes(null,

R.styleable.FastScroll, R.attr.fastScrollStyle, resId);

final int N = ta.getIndexCount();

for (int i = 0; i < N; i++) {

final int index = ta.getIndex(i);

switch (index) {

case R.styleable.FastScroll_position:

mOverlayPosition = ta.getInt(index, OVERLAY_FLOATING);

break;

case R.styleable.FastScroll_backgroundLeft:

mPreviewResId[PREVIEW_LEFT] = ta.getResourceId(index, 0);

break;

case R.styleable.FastScroll_backgroundRight:

mPreviewResId[PREVIEW_RIGHT] = ta.getResourceId(index, 0);

break;

case R.styleable.FastScroll_thumbDrawable:

mThumbDrawable = ta.getDrawable(index);

break;

case R.styleable.FastScroll_trackDrawable:

mTrackDrawable = ta.getDrawable(index);

break;

case R.styleable.FastScroll_textAppearance:

mTextAppearance = ta.getResourceId(index, 0);

break;

case R.styleable.FastScroll_textColor:

mTextColor = ta.getColorStateList(index);

break;

case R.styleable.FastScroll_textSize:

mTextSize = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_minWidth:

mPreviewMinWidth = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_minHeight:

mPreviewMinHeight = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_thumbMinWidth:

mThumbMinWidth = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_thumbMinHeight:

mThumbMinHeight = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_padding:

mPreviewPadding = ta.getDimensionPixelSize(index, 0);

break;

case R.styleable.FastScroll_thumbPosition:

mThumbPosition = ta.getInt(index, THUMB_POSITION_MIDPOINT);

break;

}

}

updateAppearance();

}

/**

* Removes this FastScroller overlay from the host view.

*/

public void remove() {

mOverlay.remove(mTrackImage);

mOverlay.remove(mThumbImage);

mOverlay.remove(mPreviewImage);

mOverlay.remove(mPrimaryText);

mOverlay.remove(mSecondaryText);

}

/**

* @param enabled Whether the fast scroll thumb is enabled.

*/

public void setEnabled(boolean enabled) {

if (mEnabled != enabled) {

mEnabled = enabled;

onStateDependencyChanged(true);

}

}

/**

* @return Whether the fast scroll thumb is enabled.

*/

public boolean isEnabled() {

return mEnabled && (mLongList || mAlwaysShow);

}

/**

* @param alwaysShow Whether the fast scroll thumb should always be shown

*/

public void setAlwaysShow(boolean alwaysShow) {

if (mAlwaysShow != alwaysShow) {

mAlwaysShow = alwaysShow;

onStateDependencyChanged(false);

}

}

/**

* @return Whether the fast scroll thumb will always be shown

* @see #setAlwaysShow(boolean)

*/

public boolean isAlwaysShowEnabled() {

return mAlwaysShow;

}

/**

* Called when one of the variables affecting enabled state changes.

*

* @param peekIfEnabled whether the thumb should peek, if enabled

*/

private void onStateDependencyChanged(boolean peekIfEnabled) {

if (isEnabled()) {

if (isAlwaysShowEnabled()) {

setState(STATE_VISIBLE);

} else if (mState == STATE_VISIBLE) {

postAutoHide();

} else if (peekIfEnabled) {

setState(STATE_VISIBLE);

postAutoHide();

}

} else {

stop();

}

mList.resolvePadding();

}

public void setScrollBarStyle(int style) {

if (mScrollBarStyle != style) {

mScrollBarStyle = style;

updateLayout();

}

}

/**

* Immediately transitions the fast scroller decorations to a hidden state.

*/

public void stop() {

setState(STATE_NONE);

}

public void setScrollbarPosition(int position) {

if (position == View.SCROLLBAR_POSITION_DEFAULT) {

position = mList.isLayoutRtl() ?

View.SCROLLBAR_POSITION_LEFT : View.SCROLLBAR_POSITION_RIGHT;

}

if (mScrollbarPosition != position) {

mScrollbarPosition = position;

mLayoutFromRight = position != View.SCROLLBAR_POSITION_LEFT;

final int previewResId = mPreviewResId[mLayoutFromRight ? PREVIEW_RIGHT : PREVIEW_LEFT];

mPreviewImage.setBackgroundResource(previewResId);

// Propagate padding to text min width/height.

final int textMinWidth = Math.max(0, mPreviewMinWidth - mPreviewImage.getPaddingLeft()

- mPreviewImage.getPaddingRight());

mPrimaryText.setMinimumWidth(textMinWidth);

mSecondaryText.setMinimumWidth(textMinWidth);

final int textMinHeight = Math.max(0, mPreviewMinHeight - mPreviewImage.getPaddingTop()

- mPreviewImage.getPaddingBottom());

mPrimaryText.setMinimumHeight(textMinHeight);

mSecondaryText.setMinimumHeight(textMinHeight);

// Requires re-layout.

updateLayout();

}

}

public int getWidth() {

return mWidth;

}

public void onSizeChanged(int w, int h, int oldw, int oldh) {

updateLayout();

}

public void onItemCountChanged(int childCount, int itemCount) {

if (mOldItemCount != itemCount || mOldChildCount != childCount) {

mOldItemCount = itemCount;

mOldChildCount = childCount;

final boolean hasMoreItems = itemCount - childCount > 0;

if (hasMoreItems && mState != STATE_DRAGGING) {

final int firstVisibleItem = mList.getFirstVisiblePosition();

setThumbPos(getPosFromItemCount(firstVisibleItem, childCount, itemCount));

}

updateLongList(childCount, itemCount);

}

}

private void updateLongList(int childCount, int itemCount) {

final boolean longList = childCount > 0 && itemCount / childCount >= MIN_PAGES;

if (mLongList != longList) {

mLongList = longList;

onStateDependencyChanged(false);

}

}

/**

* Creates a view into which preview text can be placed.

*/

private TextView createPreviewTextView(Context context) {

final LayoutParams params = new LayoutParams(

LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

final TextView textView = new TextView(context);

textView.setLayoutParams(params);

textView.setSingleLine(true);

textView.setEllipsize(TruncateAt.MIDDLE);

textView.setGravity(Gravity.CENTER);

textView.setAlpha(0f);

// Manually propagate inherited layout direction.

textView.setLayoutDirection(mList.getLayoutDirection());

return textView;

}

/**

* Measures and layouts the scrollbar and decorations.

*/

public void updateLayout() {

// Prevent re-entry when RTL properties change as a side-effect of

// resolving padding.

if (mUpdatingLayout) {

return;

}

mUpdatingLayout = true;

updateContainerRect();

layoutThumb();

layoutTrack();

updateOffsetAndRange();

final Rect bounds = mTempBounds;

measurePreview(mPrimaryText, bounds);

applyLayout(mPrimaryText, bounds);

measurePreview(mSecondaryText, bounds);

applyLayout(mSecondaryText, bounds);

if (mPreviewImage != null) {

// Apply preview image padding.

bounds.left -= mPreviewImage.getPaddingLeft();

bounds.top -= mPreviewImage.getPaddingTop();

bounds.right += mPreviewImage.getPaddingRight();

bounds.bottom += mPreviewImage.getPaddingBottom();

applyLayout(mPreviewImage, bounds);

}

mUpdatingLayout = false;

}

/**

* Layouts a view within the specified bounds and pins the pivot point to

* the appropriate edge.

*

* @param view The view to layout.

* @param bounds Bounds at which to layout the view.

*/

private void applyLayout(View view, Rect bounds) {

view.layout(bounds.left, bounds.top, bounds.right, bounds.bottom);

view.setPivotX(mLayoutFromRight ? bounds.right - bounds.left : 0);

}

/**

* Measures the preview text bounds, taking preview image padding into

* account. This method should only be called after {@link #layoutThumb()}

* and {@link #layoutTrack()} have both been called at least once.

*

* @param v The preview text view to measure.

* @param out Rectangle into which measured bounds are placed.

*/

private void measurePreview(View v, Rect out) {

// Apply the preview image's padding as layout margins.

final Rect margins = mTempMargins;

margins.left = mPreviewImage.getPaddingLeft();

margins.top = mPreviewImage.getPaddingTop();

margins.right = mPreviewImage.getPaddingRight();

margins.bottom = mPreviewImage.getPaddingBottom();

if (mOverlayPosition == OVERLAY_FLOATING) {

measureFloating(v, margins, out);

} else {

measureViewToSide(v, mThumbImage, margins, out);

}

}

/**

* Measures the bounds for a view that should be laid out against the edge

* of an adjacent view. If no adjacent view is provided, lays out against

* the list edge.

*

* @param view The view to measure for layout.

* @param adjacent (Optional) The adjacent view, may be null to align to the

* list edge.

* @param margins Layout margins to apply to the view.

* @param out Rectangle into which measured bounds are placed.

*/

private void measureViewToSide(View view, View adjacent, Rect margins, Rect out) {

final int marginLeft;

final int marginTop;

final int marginRight;

if (margins == null) {

marginLeft = 0;

marginTop = 0;

marginRight = 0;

} else {

marginLeft = margins.left;

marginTop = margins.top;

marginRight = margins.right;

}

final Rect container = mContainerRect;

final int containerWidth = container.width();

final int maxWidth;

if (adjacent == null) {

maxWidth = containerWidth;

} else if (mLayoutFromRight) {

maxWidth = adjacent.getLeft();

} else {

maxWidth = containerWidth - adjacent.getRight();

}

final int adjMaxHeight = Math.max(0, container.height());

final int adjMaxWidth = Math.max(0, maxWidth - marginLeft - marginRight);

final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(adjMaxWidth, MeasureSpec.AT_MOST);

final int heightMeasureSpec = MeasureSpec.makeSafeMeasureSpec(

adjMaxHeight, MeasureSpec.UNSPECIFIED);

view.measure(widthMeasureSpec, heightMeasureSpec);

// Align to the left or right.

final int width = Math.min(adjMaxWidth, view.getMeasuredWidth());

final int left;

final int right;

if (mLayoutFromRight) {

right = (adjacent == null ? container.right : adjacent.getLeft()) - marginRight;

left = right - width;

} else {

left = (adjacent == null ? container.left : adjacent.getRight()) + marginLeft;

right = left + width;

}

// Don't adjust the vertical position.

final int top = marginTop;

final int bottom = top + view.getMeasuredHeight();

out.set(left, top, right, bottom);

}

private void measureFloating(View preview, Rect margins, Rect out) {

final int marginLeft;

final int marginTop;

final int marginRight;

if (margins == null) {

marginLeft = 0;

marginTop = 0;

marginRight = 0;

} else {

marginLeft = margins.left;

marginTop = margins.top;

marginRight = margins.right;

}

final Rect container = mContainerRect;

final int containerWidth = container.width();

final int adjMaxHeight = Math.max(0, container.height());

final int adjMaxWidth = Math.max(0, containerWidth - marginLeft - marginRight);

final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(adjMaxWidth, MeasureSpec.AT_MOST);

final int heightMeasureSpec = MeasureSpec.makeSafeMeasureSpec(

adjMaxHeight, MeasureSpec.UNSPECIFIED);

preview.measure(widthMeasureSpec, heightMeasureSpec);

// Align at the vertical center, 10% from the top.

final int containerHeight = container.height();

final int width = preview.getMeasuredWidth();

final int top = containerHeight / 10 + marginTop + container.top;

final int bottom = top + preview.getMeasuredHeight();

final int left = (containerWidth - width) / 2 + container.left;

final int right = left + width;

out.set(left, top, right, bottom);

}

/**

* Updates the container rectangle used for layout.

*/

private void updateContainerRect() {

final AbsListView list = mList;

list.resolvePadding();

final Rect container = mContainerRect;

container.left = 0;

container.top = 0;

container.right = list.getWidth();

container.bottom = list.getHeight();

final int scrollbarStyle = mScrollBarStyle;

if (scrollbarStyle == View.SCROLLBARS_INSIDE_INSET

|| scrollbarStyle == View.SCROLLBARS_INSIDE_OVERLAY) {

container.left += list.getPaddingLeft();

container.top += list.getPaddingTop();

container.right -= list.getPaddingRight();

container.bottom -= list.getPaddingBottom();

// In inset mode, we need to adjust for padded scrollbar width.

if (scrollbarStyle == View.SCROLLBARS_INSIDE_INSET) {

final int width = getWidth();

if (mScrollbarPosition == View.SCROLLBAR_POSITION_RIGHT) {

container.right += width;

} else {

container.left -= width;

}

}

}

}

/**

* Lays out the thumb according to the current scrollbar position.

*/

private void layoutThumb() {

final Rect bounds = mTempBounds;

measureViewToSide(mThumbImage, null, null, bounds);

applyLayout(mThumbImage, bounds);

}

/**

* Lays out the track centered on the thumb. Must be called after

* {@link #layoutThumb}.

*/

private void layoutTrack() {

final View track = mTrackImage;

final View thumb = mThumbImage;

final Rect container = mContainerRect;

final int maxWidth = Math.max(0, container.width());

final int maxHeight = Math.max(0, container.height());

final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.AT_MOST);

final int heightMeasureSpec = MeasureSpec.makeSafeMeasureSpec(

maxHeight, MeasureSpec.UNSPECIFIED);

track.measure(widthMeasureSpec, heightMeasureSpec);

final int top;

final int bottom;

if (mThumbPosition == THUMB_POSITION_INSIDE) {

top = container.top;

bottom = container.bottom;

} else {

final int thumbHalfHeight = thumb.getHeight() / 2;

top = container.top + thumbHalfHeight;

bottom = container.bottom - thumbHalfHeight;

}

final int trackWidth = track.getMeasuredWidth();

final int left = thumb.getLeft() + (thumb.getWidth() - trackWidth) / 2;

final int right = left + trackWidth;

track.layout(left, top, right, bottom);

}

/**

* Updates the offset and range used to convert from absolute y-position to

* thumb position within the track.

*/

private void updateOffsetAndRange() {

final View trackImage = mTrackImage;

final View thumbImage = mThumbImage;

final float min;

final float max;

if (mThumbPosition == THUMB_POSITION_INSIDE) {

final float halfThumbHeight = thumbImage.getHeight() / 2f;

min = trackImage.getTop() + halfThumbHeight;

max = trackImage.getBottom() - halfThumbHeight;

} else{

min = trackImage.getTop();

max = trackImage.getBottom();

}

mThumbOffset = min;

mThumbRange = max - min;

}

private void setState(int state) {

mList.removeCallbacks(mDeferHide);

if (mAlwaysShow && state == STATE_NONE) {

state = STATE_VISIBLE;

}

if (state == mState) {

return;

}

switch (state) {

case STATE_NONE:

transitionToHidden();

break;

case STATE_VISIBLE:

transitionToVisible();

break;

case STATE_DRAGGING:

if (transitionPreviewLayout(mCurrentSection)) {

transitionToDragging();

} else {

transitionToVisible();

}

break;

}

mState = state;

refreshDrawablePressedState();

}

private void refreshDrawablePressedState() {

final boolean isPressed = mState == STATE_DRAGGING;

mThumbImage.setPressed(isPressed);

mTrackImage.setPressed(isPressed);

}

/**

* Shows nothing.

*/

private void transitionToHidden() {

if (mDecorAnimation != null) {

mDecorAnimation.cancel();

}

final Animator fadeOut = groupAnimatorOfFloat(View.ALPHA, 0f, mThumbImage, mTrackImage,

mPreviewImage, mPrimaryText, mSecondaryText).setDuration(DURATION_FADE_OUT);

// Push the thumb and track outside the list bounds.

final float offset = mLayoutFromRight ? mThumbImage.getWidth() : -mThumbImage.getWidth();

final Animator slideOut = groupAnimatorOfFloat(

View.TRANSLATION_X, offset, mThumbImage, mTrackImage)

.setDuration(DURATION_FADE_OUT);

mDecorAnimation = new AnimatorSet();

mDecorAnimation.playTogether(fadeOut, slideOut);

mDecorAnimation.start();

mShowingPreview = false;

}

/**

* Shows the thumb and track.

*/

private void transitionToVisible() {

if (mDecorAnimation != null) {

mDecorAnimation.cancel();

}

final Animator fadeIn = groupAnimatorOfFloat(View.ALPHA, 1f, mThumbImage, mTrackImage)

.setDuration(DURATION_FADE_IN);

final Animator fadeOut = groupAnimatorOfFloat(

View.ALPHA, 0f, mPreviewImage, mPrimaryText, mSecondaryText)

.setDuration(DURATION_FADE_OUT);

final Animator slideIn = groupAnimatorOfFloat(

View.TRANSLATION_X, 0f, mThumbImage, mTrackImage).setDuration(DURATION_FADE_IN);

mDecorAnimation = new AnimatorSet();

mDecorAnimation.playTogether(fadeIn, fadeOut, slideIn);

mDecorAnimation.start();

mShowingPreview = false;

}

/**

* Shows the thumb, preview, and track.

*/

private void transitionToDragging() {

if (mDecorAnimation != null) {

mDecorAnimation.cancel();

}

final Animator fadeIn = groupAnimatorOfFloat(

View.ALPHA, 1f, mThumbImage, mTrackImage, mPreviewImage)

.setDuration(DURATION_FADE_IN);

final Animator slideIn = groupAnimatorOfFloat(

View.TRANSLATION_X, 0f, mThumbImage, mTrackImage).setDuration(DURATION_FADE_IN);

mDecorAnimation = new AnimatorSet();

mDecorAnimation.playTogether(fadeIn, slideIn);

mDecorAnimation.start();

mShowingPreview = true;

}

private void postAutoHide() {

mList.removeCallbacks(mDeferHide);

mList.postDelayed(mDeferHide, FADE_TIMEOUT);

}

public void onScroll(int firstVisibleItem, int visibleItemCount, int totalItemCount) {

if (!isEnabled()) {

setState(STATE_NONE);

return;

}

final boolean hasMoreItems = totalItemCount - visibleItemCount > 0;

if (hasMoreItems && mState != STATE_DRAGGING) {

setThumbPos(getPosFromItemCount(firstVisibleItem, visibleItemCount, totalItemCount));

}

mScrollCompleted = true;

if (mFirstVisibleItem != firstVisibleItem) {

mFirstVisibleItem = firstVisibleItem;

// Show the thumb, if necessary, and set up auto-fade.

if (mState != STATE_DRAGGING) {

setState(STATE_VISIBLE);

postAutoHide();

}

}

}

private void getSectionsFromIndexer() {

mSectionIndexer = null;

Adapter adapter = mList.getAdapter();

if (adapter instanceof HeaderViewListAdapter) {

mHeaderCount = ((HeaderViewListAdapter) adapter).getHeadersCount();

adapter = ((HeaderViewListAdapter) adapter).getWrappedAdapter();

}

if (adapter instanceof ExpandableListConnector) {

final ExpandableListAdapter expAdapter = ((ExpandableListConnector) adapter)

.getAdapter();

if (expAdapter instanceof SectionIndexer) {

mSectionIndexer = (SectionIndexer) expAdapter;

mListAdapter = adapter;

mSections = mSectionIndexer.getSections();

}

} else if (adapter instanceof SectionIndexer) {

mListAdapter = adapter;

mSectionIndexer = (SectionIndexer) adapter;

mSections = mSectionIndexer.getSections();

} else {

mListAdapter = adapter;

mSections = null;

}

}

public void onSectionsChanged() {

mListAdapter = null;

}

/**

* Scrolls to a specific position within the section

* @param position

*/

private void scrollTo(float position) {

mScrollCompleted = false;

final int count = mList.getCount();

final Object[] sections = mSections;

final int sectionCount = sections == null ? 0 : sections.length;

int sectionIndex;

if (sections != null && sectionCount > 1) {

final int exactSection = MathUtils.constrain(

(int) (position * sectionCount), 0, sectionCount - 1);

int targetSection = exactSection;

int targetIndex = mSectionIndexer.getPositionForSection(targetSection);

sectionIndex = targetSection;