package com.mm.android.deviceaddmodule.mobilecommon.widget;
|
|
import android.content.Context;
|
import android.content.res.Resources;
|
import android.content.res.TypedArray;
|
import android.graphics.Canvas;
|
import android.graphics.Color;
|
import android.graphics.Paint;
|
import android.graphics.Rect;
|
import android.os.Handler;
|
import android.support.annotation.ColorInt;
|
import android.support.annotation.NonNull;
|
import android.support.annotation.Nullable;
|
import android.text.TextUtils;
|
import android.util.AttributeSet;
|
import android.view.MotionEvent;
|
import android.view.VelocityTracker;
|
import android.view.View;
|
import android.view.ViewConfiguration;
|
import android.widget.Scroller;
|
|
import com.mm.android.deviceaddmodule.R;
|
|
import java.text.Format;
|
import java.util.List;
|
|
/**
|
* 滚动选择器
|
*/
|
public class WheelPicker<T> extends View {
|
|
/**
|
* 数据集合
|
*/
|
private List<T> mDataList;
|
|
private Format mDataFormat;
|
|
/**
|
* Item的Text的颜色
|
*/
|
@ColorInt
|
private int mTextColor;
|
|
private int mTextSize;
|
|
private Paint mTextPaint;
|
/**
|
* 字体渐变，开启后越靠近边缘，字体越模糊
|
*/
|
private boolean mIsTextGradual;
|
|
/**
|
* 选中的Item的Text颜色
|
*/
|
@ColorInt
|
private int mSelectedItemTextColor;
|
|
/**
|
* 选中的Item的Text大小
|
*/
|
private int mSelectedItemTextSize;
|
|
private Paint mSelectedItemPaint;
|
/**
|
* 指示器文字
|
* 会在中心文字后边多绘制一个文字。
|
*/
|
private String mIndicatorText;
|
|
/**
|
* 指示器文字颜色
|
*/
|
@ColorInt
|
private int mIndicatorTextColor;
|
|
/**
|
* 指示器文字大小
|
*/
|
private int mIndicatorTextSize;
|
|
private int mIndicatorTextMargin;
|
|
private Paint mIndicatorPaint;
|
|
private Paint mPaint;
|
|
/**
|
* 最大的一个Item的文本的宽高
|
*/
|
private int mTextMaxWidth, mTextMaxHeight;
|
/**
|
* 输入的一段文字，可以用来测量 mTextMaxWidth
|
*/
|
private String mItemMaximumWidthText;
|
|
/**
|
* 显示的Item一半的数量（中心Item上下两边分别的数量）
|
* 总显示的数量为 mHalfVisibleItemCount * 2 + 1
|
*/
|
private int mHalfVisibleItemCount;
|
|
/**
|
* 两个Item之间的高度间隔
|
*/
|
private int mItemHeightSpace, mItemWidthSpace;
|
|
private int mItemHeight;
|
|
/**
|
* 当前的Item的位置
|
*/
|
private int mCurrentPosition;
|
|
/**
|
* 是否将中间的Item放大
|
*/
|
private boolean mIsZoomInSelectedItem;
|
|
/**
|
* 整个控件的可绘制面积
|
*/
|
private Rect mDrawnRect;
|
|
/**
|
* 中心被选中的Item的坐标矩形
|
*/
|
private Rect mSelectedItemRect;
|
|
/**
|
* 第一个Item的绘制Text的坐标
|
*/
|
private int mFirstItemDrawX, mFirstItemDrawY;
|
|
/**
|
* 中心的Item绘制text的Y轴坐标
|
*/
|
private int mCenterItemDrawnY;
|
|
private Scroller mScroller;
|
|
private int mTouchSlop;
|
|
/**
|
* 该标记的作用是，令mTouchSlop仅在一个滑动过程中生效一次。
|
*/
|
private boolean mTouchSlopFlag;
|
|
private VelocityTracker mTracker;
|
|
private int mTouchDownY;
|
/**
|
* Y轴Scroll滚动的位移
|
*/
|
private int mScrollOffsetY;
|
|
/**
|
* 最后手指Down事件的Y轴坐标，用于计算拖动距离
|
*/
|
private int mLastDownY;
|
|
/**
|
* 是否循环读取
|
*/
|
private boolean mIsCyclic = true;
|
|
|
/**
|
* 最大可以Fling的距离
|
*/
|
private int mMaxFlingY, mMinFlingY;
|
|
/**
|
* 选中边框的颜色
|
*/
|
@ColorInt
|
private int mSelectedBorderColor;
|
|
/**
|
* 滚轮滑动时的最小/最大速度
|
*/
|
private int mMinimumVelocity = 50, mMaximumVelocity = 8888;
|
|
/**
|
* 是否是手动停止滚动
|
*/
|
private boolean mIsAbortScroller;
|
|
private LinearGradient mLinearGradient;
|
|
private Handler mHandler = new Handler();
|
|
private OnWheelChangeListener<T> mOnWheelChangeListener;
|
|
private Runnable mScrollerRunnable = new Runnable() {
|
@Override
|
public void run() {
|
|
if (mScroller.computeScrollOffset()) {
|
|
mScrollOffsetY = mScroller.getCurrY();
|
postInvalidate();
|
mHandler.postDelayed(this, 16);
|
}
|
if (mScroller.isFinished() || (mScroller.getFinalY() == mScroller.getCurrY()
|
&& mScroller.getFinalX() == mScroller.getCurrX())) {
|
|
if (mItemHeight == 0) {
|
return;
|
}
|
int position = -mScrollOffsetY / mItemHeight;
|
position = fixItemPosition(position);
|
if (mCurrentPosition != position) {
|
mCurrentPosition = position;
|
if (mOnWheelChangeListener == null) {
|
return;
|
}
|
mOnWheelChangeListener.onWheelSelected(mDataList.get(position),
|
position);
|
}
|
}
|
}
|
};
|
|
public WheelPicker(Context context) {
|
this(context, null);
|
}
|
|
public WheelPicker(Context context, @Nullable AttributeSet attrs) {
|
this(context, attrs,0);
|
}
|
|
public WheelPicker(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
|
super(context, attrs, defStyleAttr);
|
initAttrs(context, attrs);
|
initPaint();
|
mLinearGradient = new LinearGradient(mTextColor, mSelectedItemTextColor);
|
mDrawnRect = new Rect();
|
mSelectedItemRect = new Rect();
|
mScroller = new Scroller(context);
|
|
ViewConfiguration configuration = ViewConfiguration.get(context);
|
mTouchSlop = configuration.getScaledTouchSlop();
|
}
|
|
private void initAttrs(Context context, @Nullable AttributeSet attrs) {
|
if (attrs == null) {
|
return;
|
}
|
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.WheelPicker);
|
mTextSize = a.getDimensionPixelSize(R.styleable.WheelPicker_itemTextSize,
|
getResources().getDimensionPixelSize(R.dimen.wheel_picker_text_size));
|
mTextColor = a.getColor(R.styleable.WheelPicker_itemTextColor,
|
Color.BLACK);
|
mIsTextGradual = a.getBoolean(R.styleable.WheelPicker_textGradual, true);
|
mIsCyclic = a.getBoolean(R.styleable.WheelPicker_wheelCyclic, false);
|
mHalfVisibleItemCount = a.getInteger(R.styleable.WheelPicker_halfVisibleItemCount, 2);
|
mSelectedItemTextColor = a.getColor(R.styleable.WheelPicker_selectedTextColor, Color.BLACK);
|
try {
|
mSelectedItemTextSize = a.getDimensionPixelSize(R.styleable.WheelPicker_selectedTextSize,
|
getResources().getDimensionPixelSize(R.dimen.wheel_picker_selected_text_size));
|
mCurrentPosition = a.getInteger(R.styleable.WheelPicker_currentItemPosition, 0);
|
mItemWidthSpace = a.getDimensionPixelSize(R.styleable.WheelPicker_itemWidthSpace,
|
getResources().getDimensionPixelOffset(R.dimen.mobile_common_dp_30));
|
mItemHeightSpace = a.getDimensionPixelSize(R.styleable.WheelPicker_itemHeightSpace,
|
getResources().getDimensionPixelOffset(R.dimen.mobile_common_dp_6));
|
mSelectedBorderColor = a.getColor(R.styleable.WheelPicker_selectedBorderColor, context.getResources().getColor(R.color.c51));
|
} catch (Resources.NotFoundException e) {
|
e.printStackTrace();
|
}
|
mIsZoomInSelectedItem = a.getBoolean(R.styleable.WheelPicker_zoomInSelectedItem, true);
|
mIndicatorText = a.getString(R.styleable.WheelPicker_indicatorText);
|
mIndicatorTextColor = a.getColor(R.styleable.WheelPicker_indicatorTextColor, mSelectedItemTextColor);
|
mIndicatorTextSize = a.getDimensionPixelSize(R.styleable.WheelPicker_indicatorTextSize, mTextSize);
|
mIndicatorTextMargin = 10;
|
a.recycle();
|
}
|
|
public void computeTextSize() {
|
mTextMaxWidth = mTextMaxHeight = 0;
|
if (mDataList.size() == 0) {
|
return;
|
}
|
|
//这里使用最大的,防止文字大小超过布局大小。
|
mPaint.setTextSize(mSelectedItemTextSize > mTextSize ? mSelectedItemTextSize : mTextSize);
|
|
if (!TextUtils.isEmpty(mItemMaximumWidthText)) {
|
mTextMaxWidth = (int) mPaint.measureText(mItemMaximumWidthText);
|
} else {
|
mTextMaxWidth = (int) mPaint.measureText(mDataList.get(0).toString());
|
}
|
Paint.FontMetrics metrics = mPaint.getFontMetrics();
|
mTextMaxHeight = (int) (metrics.bottom - metrics.top);
|
}
|
|
private void initPaint() {
|
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);
|
mPaint.setStyle(Paint.Style.FILL);
|
mPaint.setTextAlign(Paint.Align.CENTER);
|
mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);
|
mTextPaint.setStyle(Paint.Style.FILL);
|
mTextPaint.setTextAlign(Paint.Align.CENTER);
|
mTextPaint.setColor(mTextColor);
|
mTextPaint.setTextSize(mTextSize);
|
mSelectedItemPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);
|
mSelectedItemPaint.setStyle(Paint.Style.FILL);
|
mSelectedItemPaint.setTextAlign(Paint.Align.CENTER);
|
mSelectedItemPaint.setColor(mSelectedItemTextColor);
|
mSelectedItemPaint.setTextSize(mSelectedItemTextSize);
|
mIndicatorPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);
|
mIndicatorPaint.setStyle(Paint.Style.FILL);
|
mIndicatorPaint.setTextAlign(Paint.Align.LEFT);
|
mIndicatorPaint.setColor(mIndicatorTextColor);
|
mIndicatorPaint.setTextSize(mIndicatorTextSize);
|
}
|
|
/**
|
* 计算实际的大小
|
* @param specMode 测量模式
|
* @param specSize 测量的大小
|
* @param size 需要的大小
|
* @return 返回的数值
|
*/
|
private int measureSize(int specMode, int specSize, int size) {
|
if (specMode == MeasureSpec.EXACTLY) {
|
return specSize;
|
} else {
|
return Math.min(specSize, size);
|
}
|
}
|
|
@Override
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
int specWidthSize = MeasureSpec.getSize(widthMeasureSpec);
|
int specWidthMode = MeasureSpec.getMode(widthMeasureSpec);
|
int specHeightSize = MeasureSpec.getSize(heightMeasureSpec);
|
int specHeightMode = MeasureSpec.getMode(heightMeasureSpec);
|
|
int width = mTextMaxWidth + mItemWidthSpace;
|
int height = (mTextMaxHeight + mItemHeightSpace) * getVisibleItemCount();
|
|
width += getPaddingLeft() + getPaddingRight();
|
height += getPaddingTop() + getPaddingBottom();
|
setMeasuredDimension(measureSize(specWidthMode, specWidthSize, width),
|
measureSize(specHeightMode, specHeightSize, height));
|
}
|
|
/**
|
* 计算Fling极限
|
* 如果为Cyclic模式则为Integer的极限值，如果正常模式，则为一整个数据集的上下限。
|
*/
|
private void computeFlingLimitY() {
|
mMinFlingY = mIsCyclic ? Integer.MIN_VALUE :
|
- mItemHeight * (mDataList.size() - 1);
|
mMaxFlingY = mIsCyclic ? Integer.MAX_VALUE : 0;
|
}
|
|
@Override
|
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
|
super.onSizeChanged(w, h, oldw, oldh);
|
mDrawnRect.set(getPaddingLeft(), getPaddingTop(),
|
getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
|
mItemHeight = mDrawnRect.height() / getVisibleItemCount();
|
mFirstItemDrawX = mDrawnRect.centerX();
|
mFirstItemDrawY = (int) ((mItemHeight - (mSelectedItemPaint.ascent() + mSelectedItemPaint.descent())) / 2);
|
//中间的Item边框
|
mSelectedItemRect.set(getPaddingLeft(), mItemHeight * mHalfVisibleItemCount,
|
getWidth() - getPaddingRight(), mItemHeight + mItemHeight * mHalfVisibleItemCount);
|
computeFlingLimitY();
|
mCenterItemDrawnY = mFirstItemDrawY + mItemHeight * mHalfVisibleItemCount;
|
|
mScrollOffsetY = -mItemHeight * mCurrentPosition;
|
}
|
|
/**
|
* 修正坐标值，让其回到dateList的范围内
|
* @param position 修正前的值
|
* @return 修正后的值
|
*/
|
private int fixItemPosition(int position) {
|
if (position < 0) {
|
//将数据集限定在0 ~ mDataList.size()-1之间
|
position = mDataList.size() + (position % mDataList.size());
|
|
}
|
if (position >= mDataList.size()){
|
//将数据集限定在0 ~ mDataList.size()-1之间
|
position = position % mDataList.size();
|
}
|
return position;
|
}
|
|
@Override
|
protected void onDraw(Canvas canvas) {
|
super.onDraw(canvas);
|
mPaint.setStyle(Paint.Style.STROKE);
|
mPaint.setColor(mSelectedBorderColor);
|
canvas.drawRect(mSelectedItemRect, mPaint);
|
|
if(mDrawnRect != null){
|
canvas.drawRect(mDrawnRect, mPaint);
|
}
|
|
|
mPaint.setTextAlign(Paint.Align.CENTER);
|
int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
|
mPaint.setStyle(Paint.Style.FILL);
|
//首尾各多绘制一个用于缓冲
|
for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;
|
drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
|
int position = drawDataPos;
|
if (mIsCyclic) {
|
position = fixItemPosition(position);
|
} else {
|
if (position < 0 || position > mDataList.size() - 1) {
|
continue;
|
}
|
}
|
|
T data = mDataList.get(position);
|
int itemDrawY = mFirstItemDrawY + (drawDataPos + mHalfVisibleItemCount) * mItemHeight + mScrollOffsetY;
|
//距离中心的Y轴距离
|
int distanceY = Math.abs(mCenterItemDrawnY - itemDrawY);
|
|
if (mIsTextGradual) {
|
//文字颜色渐变要在设置透明度上边，否则会被覆盖
|
//计算文字颜色渐变
|
if (distanceY < mItemHeight) { //距离中心的高度小于一个ItemHeight才会开启渐变
|
float colorRatio = 1 - (distanceY / (float) mItemHeight);
|
mSelectedItemPaint.setColor(mLinearGradient.getColor(colorRatio));
|
mTextPaint.setColor(mLinearGradient.getColor(colorRatio));
|
} else {
|
mSelectedItemPaint.setColor(mSelectedItemTextColor);
|
mTextPaint.setColor(mTextColor);
|
}
|
//计算透明度渐变
|
float alphaRatio;
|
if (itemDrawY > mCenterItemDrawnY && mDrawnRect != null) {
|
alphaRatio = (mDrawnRect.height() - itemDrawY) /
|
(float) (mDrawnRect.height() - (mCenterItemDrawnY));
|
} else {
|
alphaRatio = itemDrawY / (float) mCenterItemDrawnY;
|
}
|
|
alphaRatio = alphaRatio < 0 ? 0 :alphaRatio;
|
mSelectedItemPaint.setAlpha((int) (alphaRatio * 255));
|
mTextPaint.setAlpha((int) (alphaRatio * 255));
|
}
|
|
//开启此选项,会将越靠近中心的Item字体放大
|
if (mIsZoomInSelectedItem) {
|
if (distanceY < mItemHeight) {
|
float addedSize = (mItemHeight - distanceY) / (float) mItemHeight * (mSelectedItemTextSize - mTextSize);
|
mSelectedItemPaint.setTextSize(mTextSize + addedSize);
|
mTextPaint.setTextSize(mTextSize + addedSize);
|
} else {
|
mSelectedItemPaint.setTextSize(mTextSize);
|
mTextPaint.setTextSize(mTextSize);
|
}
|
} else {
|
mSelectedItemPaint.setTextSize(mTextSize);
|
mTextPaint.setTextSize(mTextSize);
|
}
|
String drawText = mDataFormat == null ? data.toString() : mDataFormat.format(data);
|
if (drawText == null)
|
drawText = "";
|
|
//文字超出部分省略号代替
|
if (mDrawnRect != null) {
|
float width = Math.abs(mDrawnRect.right - mDrawnRect.left);
|
if (width > 0 && !TextUtils.isEmpty(drawText)) {
|
float textWidth = mTextPaint.measureText(drawText);
|
if (textWidth > width) {
|
int subIndex = mTextPaint.breakText(drawText, 0, drawText.length(), true, width, null);
|
if (subIndex > 3 && subIndex <= drawText.length())
|
drawText = drawText.substring(0, subIndex - 3) + "...";
|
}
|
}
|
}
|
|
//在中间位置的Item作为被选中的。
|
if (distanceY < mItemHeight / 2) {
|
canvas.drawText(drawText, mFirstItemDrawX, itemDrawY, mSelectedItemPaint);
|
} else {
|
canvas.drawText(drawText, mFirstItemDrawX, itemDrawY, mTextPaint);
|
}
|
}
|
if (!TextUtils.isEmpty(mIndicatorText)) {
|
canvas.drawText(mIndicatorText, mFirstItemDrawX + mTextMaxWidth / 2 + mIndicatorTextMargin, mCenterItemDrawnY, mIndicatorPaint);
|
}
|
}
|
|
|
@Override
|
public boolean onTouchEvent(MotionEvent event) {
|
if (mTracker == null) {
|
mTracker = VelocityTracker.obtain();
|
}
|
mTracker.addMovement(event);
|
switch (event.getAction()) {
|
case MotionEvent.ACTION_DOWN:
|
if (!mScroller.isFinished()) {
|
mScroller.abortAnimation();
|
mIsAbortScroller = true;
|
} else {
|
mIsAbortScroller = false;
|
}
|
mTracker.clear();
|
mTouchDownY = mLastDownY = (int) event.getY();
|
mTouchSlopFlag = true;
|
break;
|
case MotionEvent.ACTION_MOVE:
|
if (mTouchSlopFlag && Math.abs(mTouchDownY - event.getY()) < mTouchSlop) {
|
break;
|
}
|
mTouchSlopFlag = false;
|
float move = event.getY() - mLastDownY;
|
move = (move * 6) / 10; //减少滚动的距离
|
mScrollOffsetY += move;
|
mLastDownY = (int) event.getY();
|
invalidate();
|
break;
|
case MotionEvent.ACTION_UP:
|
if (!mIsAbortScroller && mTouchDownY == mLastDownY) {
|
performClick();
|
if (event.getY() > mSelectedItemRect.bottom) {
|
int scrollItem = (int) (event.getY() - mSelectedItemRect.bottom) / mItemHeight + 1;
|
mScroller.startScroll(0, mScrollOffsetY, 0,
|
-scrollItem * mItemHeight);
|
|
} else if (event.getY() < mSelectedItemRect.top) {
|
int scrollItem = (int) (mSelectedItemRect.top - event.getY()) / mItemHeight + 1;
|
mScroller.startScroll(0, mScrollOffsetY, 0,
|
scrollItem * mItemHeight);
|
}
|
} else {
|
mTracker.computeCurrentVelocity(1000, mMaximumVelocity);
|
int velocity = (int) mTracker.getYVelocity();
|
if (Math.abs(velocity) > mMinimumVelocity) {
|
mScroller.fling(0, mScrollOffsetY, 0, velocity,
|
0, 0, mMinFlingY, mMaxFlingY);
|
mScroller.setFinalY(mScroller.getFinalY() +
|
computeDistanceToEndPoint(mScroller.getFinalY() % mItemHeight));
|
} else {
|
mScroller.startScroll(0, mScrollOffsetY, 0,
|
computeDistanceToEndPoint(mScrollOffsetY % mItemHeight));
|
}
|
}
|
if (!mIsCyclic) {
|
if (mScroller.getFinalY() > mMaxFlingY) {
|
mScroller.setFinalY(mMaxFlingY);
|
} else if (mScroller.getFinalY() < mMinFlingY) {
|
mScroller.setFinalY(mMinFlingY);
|
}
|
}
|
mHandler.post(mScrollerRunnable);
|
mTracker.recycle();
|
mTracker = null;
|
break;
|
}
|
return true;
|
}
|
|
@Override
|
public boolean performClick() {
|
return super.performClick();
|
}
|
|
private int computeDistanceToEndPoint(int remainder) {
|
if (Math.abs(remainder) > mItemHeight / 2) {
|
if (mScrollOffsetY < 0) {
|
return -mItemHeight - remainder;
|
} else {
|
return mItemHeight - remainder;
|
}
|
} else {
|
return -remainder;
|
}
|
}
|
|
|
public void setOnWheelChangeListener(OnWheelChangeListener<T> onWheelChangeListener) {
|
mOnWheelChangeListener = onWheelChangeListener;
|
}
|
|
public Paint getTextPaint() {
|
return mTextPaint;
|
}
|
|
public Paint getSelectedItemPaint() {
|
return mSelectedItemPaint;
|
}
|
|
public Paint getPaint() {
|
return mPaint;
|
}
|
|
public Paint getIndicatorPaint() {
|
return mIndicatorPaint;
|
}
|
|
public List<T> getDataList() {
|
return mDataList;
|
}
|
|
public void setDataList(@NonNull List<T> dataList) {
|
mDataList = dataList;
|
if (dataList.size() == 0) {
|
return;
|
}
|
int maxWidth = 0;
|
for (T t:mDataList) {
|
int tem = (int) mPaint.measureText(t.toString());
|
if (maxWidth < tem) {
|
maxWidth = tem;
|
mItemMaximumWidthText = t.toString();
|
}
|
}
|
computeTextSize();
|
computeFlingLimitY();
|
requestLayout();
|
postInvalidate();
|
}
|
|
public int getTextColor() {
|
return mTextColor;
|
}
|
|
/**
|
* 一般列表的文本颜色
|
* @param textColor 文本颜色
|
*/
|
public void setTextColor(@ColorInt int textColor) {
|
if (mTextColor == textColor) {
|
return;
|
}
|
mTextPaint.setColor(textColor);
|
mTextColor = textColor;
|
mLinearGradient.setStartColor(textColor);
|
postInvalidate();
|
}
|
|
public int getTextSize() {
|
return mTextSize;
|
}
|
|
/**
|
* 一般列表的文本大小
|
* @param textSize 文字大小
|
*/
|
public void setTextSize(int textSize) {
|
if (mTextSize == textSize) {
|
return;
|
}
|
mTextSize = textSize;
|
mTextPaint.setTextSize(textSize);
|
computeTextSize();
|
postInvalidate();
|
}
|
|
public int getSelectedItemTextColor() {
|
return mSelectedItemTextColor;
|
}
|
|
/**
|
* 设置被选中时候的文本颜色
|
* @param selectedItemTextColor 文本颜色
|
*/
|
public void setSelectedItemTextColor(@ColorInt int selectedItemTextColor) {
|
if (mSelectedItemTextColor == selectedItemTextColor) {
|
return;
|
}
|
mSelectedItemPaint.setColor(selectedItemTextColor);
|
mSelectedItemTextColor = selectedItemTextColor;
|
mLinearGradient.setEndColor(selectedItemTextColor);
|
postInvalidate();
|
}
|
|
public int getSelectedItemTextSize() {
|
return mSelectedItemTextSize;
|
}
|
|
/**
|
* 设置被选中时候的文本大小
|
* @param selectedItemTextSize 文字大小
|
*/
|
public void setSelectedItemTextSize(int selectedItemTextSize) {
|
if (mSelectedItemTextSize == selectedItemTextSize) {
|
return;
|
}
|
mSelectedItemPaint.setTextSize(selectedItemTextSize);
|
mSelectedItemTextSize = selectedItemTextSize;
|
computeTextSize();
|
postInvalidate();
|
}
|
|
|
public String getItemMaximumWidthText() {
|
return mItemMaximumWidthText;
|
}
|
|
/**
|
* 设置输入的一段文字，用来测量 mTextMaxWidth
|
* @param itemMaximumWidthText 文本内容
|
*/
|
public void setItemMaximumWidthText(String itemMaximumWidthText) {
|
mItemMaximumWidthText = itemMaximumWidthText;
|
requestLayout();
|
postInvalidate();
|
}
|
|
public int getHalfVisibleItemCount() {
|
return mHalfVisibleItemCount;
|
}
|
|
/**
|
* 显示的个数等于上下两边Item的个数+ 中间的Item
|
* @return 总显示的数量
|
*/
|
public int getVisibleItemCount() {
|
return mHalfVisibleItemCount * 2 + 1;
|
}
|
|
/**
|
* 设置显示数据量的个数的一半。
|
* 为保证总显示个数为奇数,这里将总数拆分，总数为 mHalfVisibleItemCount * 2 + 1
|
* @param halfVisibleItemCount 总数量的一半
|
*/
|
public void setHalfVisibleItemCount(int halfVisibleItemCount) {
|
if (mHalfVisibleItemCount == halfVisibleItemCount) {
|
return;
|
}
|
mHalfVisibleItemCount = halfVisibleItemCount;
|
requestLayout();
|
}
|
|
public int getItemWidthSpace() {
|
return mItemWidthSpace;
|
}
|
|
public void setItemWidthSpace(int itemWidthSpace) {
|
if (mItemWidthSpace == itemWidthSpace) {
|
return;
|
}
|
mItemWidthSpace = itemWidthSpace;
|
requestLayout();
|
}
|
|
public int getItemHeightSpace() {
|
return mItemHeightSpace;
|
}
|
|
/**
|
* 设置两个Item之间的间隔
|
* @param itemHeightSpace 间隔值
|
*/
|
public void setItemHeightSpace(int itemHeightSpace) {
|
if (mItemHeightSpace == itemHeightSpace) {
|
return;
|
}
|
mItemHeightSpace = itemHeightSpace;
|
requestLayout();
|
}
|
|
public int getCurrentPosition() {
|
return mCurrentPosition;
|
}
|
|
/**
|
* 设置当前选中的列表项,将滚动到所选位置
|
* @param currentPosition 设置的当前位置
|
*/
|
public void setCurrentPosition(int currentPosition) {
|
setCurrentPosition(currentPosition, true);
|
}
|
|
/**
|
* 设置当前选中的列表位置
|
* @param currentPosition 设置的当前位置
|
* @param smoothScroll 是否平滑滚动
|
*/
|
public synchronized void setCurrentPosition(int currentPosition, boolean smoothScroll) {
|
if (currentPosition > mDataList.size() - 1) {
|
currentPosition = mDataList.size() - 1;
|
}
|
if (currentPosition < 0) {
|
currentPosition = 0;
|
}
|
if (mCurrentPosition == currentPosition) {
|
return;
|
}
|
if (!mScroller.isFinished()) {
|
mScroller.abortAnimation();
|
}
|
|
//如果mItemHeight=0代表还没有绘制完成，这时平滑滚动没有意义
|
if (smoothScroll && mItemHeight > 0) {
|
mScroller.startScroll(0, mScrollOffsetY, 0, (mCurrentPosition - currentPosition) * mItemHeight);
|
// mScroller.setFinalY(mScroller.getFinalY() +
|
// computeDistanceToEndPoint(mScroller.getFinalY() % mItemHeight));
|
int finalY = -currentPosition * mItemHeight;
|
mScroller.setFinalY(finalY);
|
mHandler.post(mScrollerRunnable);
|
} else {
|
mCurrentPosition = currentPosition;
|
mScrollOffsetY = -mItemHeight * mCurrentPosition;
|
postInvalidate();
|
if (mOnWheelChangeListener != null) {
|
mOnWheelChangeListener.onWheelSelected(mDataList.get(currentPosition), currentPosition);
|
}
|
}
|
}
|
|
public boolean isZoomInSelectedItem() {
|
return mIsZoomInSelectedItem;
|
}
|
|
public void setZoomInSelectedItem(boolean zoomInSelectedItem) {
|
if (mIsZoomInSelectedItem == zoomInSelectedItem) {
|
return;
|
}
|
mIsZoomInSelectedItem = zoomInSelectedItem;
|
postInvalidate();
|
}
|
|
public boolean isCyclic() {
|
return mIsCyclic;
|
}
|
|
/**
|
* 设置是否循环滚动。
|
* @param cyclic 上下边界是否相邻
|
*/
|
public void setCyclic(boolean cyclic) {
|
if (mIsCyclic == cyclic) {
|
return;
|
}
|
mIsCyclic = cyclic;
|
computeFlingLimitY();
|
requestLayout();
|
}
|
|
public int getMinimumVelocity() {
|
return mMinimumVelocity;
|
}
|
|
/**
|
* 设置最小滚动速度,如果实际速度小于此速度，将不会触发滚动。
|
* @param minimumVelocity 最小速度
|
*/
|
public void setMinimumVelocity(int minimumVelocity) {
|
mMinimumVelocity = minimumVelocity;
|
}
|
|
public int getMaximumVelocity() {
|
return mMaximumVelocity;
|
}
|
|
/**
|
* 设置最大滚动的速度,实际滚动速度的上限
|
* @param maximumVelocity 最大滚动速度
|
*/
|
public void setMaximumVelocity(int maximumVelocity) {
|
mMaximumVelocity = maximumVelocity;
|
}
|
|
public boolean isTextGradual() {
|
return mIsTextGradual;
|
}
|
|
/**
|
* 设置文字渐变，离中心越远越淡。
|
* @param textGradual 是否渐变
|
*/
|
public void setTextGradual(boolean textGradual) {
|
if (mIsTextGradual == textGradual) {
|
return;
|
}
|
mIsTextGradual = textGradual;
|
postInvalidate();
|
}
|
|
public void setIndicatorText(String indicatorText) {
|
mIndicatorText = indicatorText;
|
postInvalidate();
|
}
|
|
public void setIndicatorTextColor(int indicatorTextColor) {
|
mIndicatorTextColor = indicatorTextColor;
|
mIndicatorPaint.setColor(mIndicatorTextColor);
|
postInvalidate();
|
}
|
|
public void setIndicatorTextSize(int indicatorTextSize) {
|
mIndicatorTextSize = indicatorTextSize;
|
mIndicatorPaint.setTextSize(mIndicatorTextSize);
|
postInvalidate();
|
}
|
|
/**
|
* 设置数据集格式
|
* @param dataFormat 格式
|
*/
|
public void setDataFormat(Format dataFormat) {
|
mDataFormat = dataFormat;
|
postInvalidate();
|
}
|
|
public Format getDataFormat() {
|
return mDataFormat;
|
}
|
|
public interface OnWheelChangeListener<T> {
|
void onWheelSelected(T item, int position);
|
}
|
|
/**
|
* 颜色线性渐变工具
|
* Created by ycuwq on 2018/1/6.
|
*/
|
private class LinearGradient {
|
private int mStartColor;
|
private int mEndColor;
|
private int mRedStart;
|
private int mBlueStart;
|
private int mGreenStart;
|
private int mRedEnd;
|
private int mBlueEnd;
|
private int mGreenEnd;
|
|
private LinearGradient(@ColorInt int startColor, @ColorInt int endColor) {
|
mStartColor = startColor;
|
mEndColor = endColor;
|
updateColor();
|
}
|
|
public void setStartColor(@ColorInt int startColor) {
|
mStartColor = startColor;
|
updateColor();
|
}
|
|
public void setEndColor(@ColorInt int endColor) {
|
mEndColor = endColor;
|
updateColor();
|
}
|
|
private void updateColor() {
|
mRedStart = Color.red(mStartColor);
|
mBlueStart = Color.blue(mStartColor);
|
mGreenStart = Color.green(mStartColor);
|
mRedEnd = Color.red(mEndColor);
|
mBlueEnd = Color.blue(mEndColor);
|
mGreenEnd = Color.green(mEndColor);
|
}
|
|
public int getColor(float ratio) {
|
int red = (int) (mRedStart + ((mRedEnd - mRedStart) * ratio + 0.3));
|
int greed = (int) (mGreenStart + ((mGreenEnd - mGreenStart) * ratio + 0.3));
|
int blue = (int) (mBlueStart + ((mBlueEnd - mBlueStart) * ratio + 0.3));
|
return Color.argb(125,red, greed, blue);
|
}
|
}
|
|
}
|
