public class ZzHorizontalProgressBar extends View {
private int max;
private double progress;
private int bgColor;
private int progressColor;
private int padding;
private boolean openGradient;
private int gradientFrom;
private int gradientTo;
private boolean showSecondProgress;
private int secondProgress;
private int secondProgressShape;
private boolean showZeroPoint;
private Paint secondProgressPaint;
private Paint secondGradientPaint;
private Paint progressPaint;
private Paint gradientPaint;
private Paint bgPaint;
private boolean openSecondGradient;
private int secondGradientFrom;
private int secondGradientTo;
private int secondProgressColor;
private int radius;
private boolean drawBorder = false;
private int borderColor;
private int borderWidth;
/**
* 文字百分比的字体大小（sp）
*/
private int paintTextSize;
/**
* 百分比文字的颜色
*/
private int paintTextColor;
/**
* 画中间的百分比文字的画笔
*/
private Paint paintText;
/**
* 要画的文字的宽度
*/
private int textWidth;
/**
* 画文字时底部的坐标
*/
private float textBottomY;
/**
* 得到自定义视图的Y轴中心点
*/
private int viewCenterY;
/**
* 包裹文字的矩形
*/
private Rect rect = new Rect();
/**
* 得到自定义视图的宽度
*/
private int viewWidth;
/**
* 文字总共移动的长度（即从0%到100%文字左侧移动的长度）
*/
private int totalMovedLength;
/**
* Contxt
*/
private Context context;
// private boolean useRectMode = false;
private int showMode = 0;
private Paint borderPaint;
public static enum ShowMode {
ROUND, RECT, ROUND_RECT
}
private String mText;
private OnProgressChangedListener onProgressChangedListener;
public interface OnProgressChangedListener {
void onProgressChanged(ZzHorizontalProgressBar progressBar, int max, double progress);
void onSecondProgressChanged(ZzHorizontalProgressBar progressBar, int max, double progress);
}
public ZzHorizontalProgressBar(Context context) {
super(context);
this.context = context;
init(context, null);
}
public ZzHorizontalProgressBar(Context context, AttributeSet attrs) {
super(context, attrs);
init(context, attrs);
}
public ZzHorizontalProgressBar(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context, attrs);
}
private void init(Context context, AttributeSet attrs) {
initAttrs(context, attrs);
initPaths();
}
private void initAttrs(Context context, AttributeSet attrs) {
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ZzHorizontalProgressBar);
max = a.getInteger(R.styleable.ZzHorizontalProgressBar_zpb_max, 100);
progress = a.getInteger(R.styleable.ZzHorizontalProgressBar_zpb_progress, 0);
bgColor = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_bg_color, 0xffB8B8B8);
progressColor = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_pb_color, 0xffFF4081);
secondProgressColor = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_second_pb_color, 0xffFF4081);
padding = a.getDimensionPixelSize(R.styleable.ZzHorizontalProgressBar_zpb_padding, 0);
showZeroPoint = a.getBoolean(R.styleable.ZzHorizontalProgressBar_zpb_show_zero_point, false);
showSecondProgress = a.getBoolean(R.styleable.ZzHorizontalProgressBar_zpb_show_second_progress, false);
secondProgress = a.getInteger(R.styleable.ZzHorizontalProgressBar_zpb_second_progress, 0);
secondProgressShape = a.getInteger(R.styleable.ZzHorizontalProgressBar_zpb_show_second_point_shape, 0);
openGradient = a.getBoolean(R.styleable.ZzHorizontalProgressBar_zpb_open_gradient, false);
gradientFrom = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_gradient_from, 0xffFF4081);
paintTextColor = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_text, 0xffcd5c5c);
gradientTo = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_gradient_to, 0xffFF4081);
openSecondGradient = a.getBoolean(R.styleable.ZzHorizontalProgressBar_zpb_open_second_gradient, false);
showMode = a.getInt(R.styleable.ZzHorizontalProgressBar_zpb_show_mode, 0);
secondGradientFrom = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_second_gradient_from, 0xffFF4081);
secondGradientTo = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_second_gradient_to, 0xffFF4081);
radius = a.getDimensionPixelSize(R.styleable.ZzHorizontalProgressBar_zpb_round_rect_radius, 20);
drawBorder = a.getBoolean(R.styleable.ZzHorizontalProgressBar_zpb_draw_border, false);
borderWidth = a.getDimensionPixelSize(R.styleable.ZzHorizontalProgressBar_zpb_border_width, 1);
paintTextSize = a.getDimensionPixelSize(R.styleable.ZzHorizontalProgressBar_zpb_border_width, 20);
borderColor = a.getColor(R.styleable.ZzHorizontalProgressBar_zpb_border_color, 0xffff001f);
a.recycle();
}
private void initPaths() {
progressPaint = new Paint();
progressPaint.setColor(progressColor);
progressPaint.setStyle(Paint.Style.FILL);
progressPaint.setAntiAlias(true);
secondProgressPaint = new Paint();
secondProgressPaint.setColor(secondProgressColor);
secondProgressPaint.setStyle(Paint.Style.FILL);
secondProgressPaint.setAntiAlias(true);
gradientPaint = new Paint();
gradientPaint.setStyle(Paint.Style.FILL);
gradientPaint.setAntiAlias(true);
secondGradientPaint = new Paint();
secondGradientPaint.setStyle(Paint.Style.FILL);
secondGradientPaint.setAntiAlias(true);
bgPaint = new Paint();
bgPaint.setColor(bgColor);
bgPaint.setStyle(Paint.Style.FILL);
bgPaint.setAntiAlias(true);
borderPaint = new Paint();
borderPaint.setColor(borderColor);
borderPaint.setStyle(Paint.Style.STROKE);
borderPaint.setStrokeWidth(borderWidth);
borderPaint.setAntiAlias(true);
//设置百分比文字的尺寸
// int paintTextSizePx = sp2px(context, paintTextSize);
// 百分比文字画笔的属性
paintText = new Paint();
mText = "Udf32fA";
// paintText.setColor(Color.BLACK);
paintText.setColor(Color.parseColor("#333333"));
paintText.setTextSize(30);
paintText.setAntiAlias(true);
paintText.setTypeface(Typeface.DEFAULT_BOLD);
//获得绘制文本的宽和高
rect = new Rect();
paintText.getTextBounds(mText, 0, mText.length(), rect);
}
/**
* 得到视图等的高度宽度尺寸数据
*/
private void getWidthAndHeight() {
//得到包围文字的矩形的宽高
paintText.getTextBounds("000%", 0, "000%".length(), rect);
textWidth = rect.width();
textBottomY = viewCenterY + rect.height() / 2;
//得到自定义视图的高度
int viewHeight = getMeasuredHeight();
viewWidth = getMeasuredWidth();
viewCenterY = viewHeight / 2;
totalMovedLength = viewWidth - textWidth;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
switch (showMode) {
case 0:
//half cicle
drawBackground(canvas);
drawProgress(canvas);
drawBorder(canvas);
break;
case 1:
//rect
drawBackgroundRectMode(canvas);
drawProgressRectMode(canvas);
drawBorderRect(canvas);
break;
case 2:
//custom radius
drawBackgroundRoundRectMode(canvas);
drawProgressRoundRectMode(canvas);
drawBorderRoundRect(canvas);
break;
}
// canvas.drawText(progress + "%",progress, padding + progressHeight / 2, paintText);
// canvas.drawText(mText + "%", percent, width, paintText);
// canvas.drawText(progress + "%", getWidth() / 2 - rect.width() / 2, getHeight() / 2 + rect.height() / 2, paintText);
Log.i("aaaa", "onDraw: " + (getWidth() / 2 - rect.width() / 2) + "------------" + (getHeight() / 2 + rect.height() / 2));
}
private void drawProgress(Canvas canvas) {
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
double percent = 0;
if (max != 0) {
percent = progress * 1.0f / max;
}
int progressHeight = getHeight() - padding * 2;
if (progressHeight % 2 != 0) {
progressHeight = progressHeight - 1;
}
if (openGradient) {
int progressWidth = width - padding * 2;
float mDx = convertToFloat(progressWidth * percent);
int colors[] = new int[2];
float positions[] = new float[2];
//from color
colors[0] = gradientFrom;
positions[0] = 0;
//to color
colors[1] = gradientTo;
positions[1] = 1;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2, padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR);
//gradient
gradientPaint.setShader(shader);
int radius = width > getHeight() ? getHeight() / 2 : width / 2;
if (mDx < getHeight()) {
//left circle
if (progress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + progressHeight / 2, padding + progressHeight / 2, progressHeight / 2, gradientPaint);
}
} else {
canvas.drawCircle(padding + progressHeight / 2, padding + progressHeight / 2, progressHeight / 2, gradientPaint);
}
} else {
//progress line
RectF rectF = new RectF(padding, padding, padding + mDx, padding + progressHeight);
canvas.drawRoundRect(rectF, radius, radius, gradientPaint);
}
} else {
int progressWidth = width - padding * 2 - progressHeight;
float dx = convertToFloat(progressWidth * percent);
progressPaint.setColor(progressColor);
//left circle
if (progress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + progressHeight / 2, padding + progressHeight / 2, progressHeight / 2, progressPaint);
}
} else {
canvas.drawCircle(padding + progressHeight / 2, padding + progressHeight / 2, progressHeight / 2, progressPaint);
}
//right circle
if (progress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + progressHeight / 2 + dx, padding + progressHeight / 2, progressHeight / 2, progressPaint);
}
} else {
canvas.drawCircle(padding + progressHeight / 2 + dx, padding + progressHeight / 2, progressHeight / 2, progressPaint);
}
//middle line
RectF midRecf = new RectF(padding + progressHeight / 2, padding, padding + progressHeight / 2 + dx, padding + progressHeight);
canvas.drawRect(midRecf, progressPaint);
//得到float型进度
float progressFloat = convertToFloat(progress / 100.0f);
//当前文字移动的长度
float currentMovedLentgh = totalMovedLength * progressFloat;
// canvas.drawText(progress + "%", (getWidth() / 2 - rect.width() / 2) + progress, getHeight() / 2 + rect.height() / 2, paintText);
if (progress > 95) {
canvas.drawText(progress + "%", currentMovedLentgh - textWidth / 2, getHeight() / 2 + rect.height() / 2, paintText);
} else {
canvas.drawText(progress + "%", currentMovedLentgh + textWidth, getHeight() / 2 + rect.height() / 2, paintText);
}
}
//draw second progress
if (showSecondProgress) {
float s_percent = 0;
if (max != 0) {
s_percent = secondProgress * 1.0f / max;
}
int s_progressHeight = getHeight() - padding * 2;
if (s_progressHeight % 2 != 0) {
s_progressHeight = s_progressHeight - 1;
}
if (openSecondGradient) {
int s_progressWidth = width - padding * 2;
float s_mDx = s_progressWidth * s_percent;
int s_colors[] = new int[2];
float s_positions[] = new float[2];
//from color
s_colors[0] = secondGradientFrom;
s_positions[0] = 0;
//to color
s_colors[1] = secondGradientTo;
s_positions[1] = 1;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2, padding, padding + s_progressHeight / 2 + s_mDx, padding + s_progressHeight,
s_colors,
s_positions,
Shader.TileMode.MIRROR);
//gradient
secondGradientPaint.setShader(s_shader);
int s_radius = width > getHeight() ? getHeight() / 2 : width / 2;
if (s_mDx < getHeight()) {
//left circle
if (secondProgress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + s_progressHeight / 2, padding + s_progressHeight / 2, s_progressHeight / 2, secondGradientPaint);
}
} else {
canvas.drawCircle(padding + s_progressHeight / 2, padding + s_progressHeight / 2, s_progressHeight / 2, secondGradientPaint);
}
} else {
//progress line
RectF rectF = new RectF(padding, padding, padding + s_mDx, padding + s_progressHeight);
canvas.drawRoundRect(rectF, s_radius, s_radius, secondGradientPaint);
}
} else {
//no gradient
if (secondProgressShape == 0) {
//point shape
int s_progressWidth = width - padding * 2;
float s_mDx = s_progressWidth * s_percent;
//progress line
float px = padding + s_progressHeight / 2 + s_mDx;
if (px < width - padding - s_progressHeight / 2) {
if (secondProgress == 0) {
if (showZeroPoint) {
canvas.drawCircle(px, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
} else {
canvas.drawCircle(px, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
} else {
canvas.drawCircle(px - s_progressHeight, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
} else {
//line shape
int s_progressWidth = width - padding * 2 - s_progressHeight;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor(secondProgressColor);
//left circle
if (secondProgress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + s_progressHeight / 2, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
} else {
canvas.drawCircle(padding + s_progressHeight / 2, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
//right circle
if (secondProgress == 0) {
if (showZeroPoint) {
canvas.drawCircle(padding + s_progressHeight / 2 + dx, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
} else {
canvas.drawCircle(padding + s_progressHeight / 2 + dx, padding + s_progressHeight / 2, s_progressHeight / 2, secondProgressPaint);
}
//middle line
RectF midRecf = new RectF(padding + s_progressHeight / 2, padding, padding + s_progressHeight / 2 + dx, padding + s_progressHeight);
canvas.drawRect(midRecf, secondProgressPaint);
}
}
}
}
public static Float convertToFloat(Double doubleValue) {
return doubleValue == null ? null : doubleValue.floatValue();
}
//
private void drawProgressRectMode(Canvas canvas) {
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
float percent = 0;
if (max != 0) {
percent = convertToFloat(progress * 1.0f / max);
}
int progressHeight = getHeight() - padding * 2;
if (progressHeight % 2 != 0) {
progressHeight = progressHeight - 1;
}
if (openGradient) {
int progressWidth = width - padding * 2;
float mDx = progressWidth * percent;
int colors[] = new int[2];
float positions[] = new float[2];
//from color
colors[0] = gradientFrom;
positions[0] = 0;
//to color
colors[1] = gradientTo;
positions[1] = 1;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2, padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR);
//gradient
gradientPaint.setShader(shader);
int radius = width > getHeight() ? getHeight() / 2 : width / 2;
//progress line
RectF rectF = new RectF(padding, padding, padding + mDx, padding + progressHeight);
canvas.drawRect(rectF, gradientPaint);
} else {
int progressWidth = width - padding * 2;
float dx = progressWidth * percent;
progressPaint.setColor(progressColor);
RectF midRecf = new RectF(padding, padding, padding + dx, padding + progressHeight);
canvas.drawRect(midRecf, progressPaint);
}
//draw second progress
if (showSecondProgress) {
float s_percent = 0;
if (max != 0) {
s_percent = secondProgress * 1.0f / max;
}
int s_progressHeight = getHeight() - padding * 2;
if (s_progressHeight % 2 != 0) {
s_progressHeight = s_progressHeight - 1;
}
if (openSecondGradient) {
int s_progressWidth = width - padding * 2;
float s_mDx = s_progressWidth * s_percent;
int s_colors[] = new int[2];
float s_positions[] = new float[2];
//from color
s_colors[0] = secondGradientFrom;
s_positions[0] = 0;
//to color
s_colors[1] = secondGradientTo;
s_positions[1] = 1;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2, padding, padding + s_progressHeight / 2 + s_mDx, padding + s_progressHeight,
s_colors,
s_positions,
Shader.TileMode.MIRROR);
//gradient
secondGradientPaint.setShader(s_shader);
//progress line
RectF rectF = new RectF(padding, padding, padding + s_mDx, padding + s_progressHeight);
canvas.drawRect(rectF, secondGradientPaint);
} else {
//no gradient
//line shape
int s_progressWidth = width - padding * 2;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor(secondProgressColor);
RectF midRecf = new RectF(padding, padding, padding + dx, padding + s_progressHeight);
canvas.drawRect(midRecf, secondProgressPaint);
}
}
}
private void drawProgressRoundRectMode(Canvas canvas) {
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
float percent = 0;
if (max != 0) {
percent = convertToFloat(progress * 1.0f / max);
}
int progressHeight = getHeight() - padding * 2;
if (progressHeight % 2 != 0) {
progressHeight = progressHeight - 1;
}
if (openGradient) {
int progressWidth = width - padding * 2 - borderWidth;
float mDx = progressWidth * percent;
int colors[] = new int[2];
float positions[] = new float[2];
//from color
colors[0] = gradientFrom;
positions[0] = 0;
//to color
colors[1] = gradientTo;
positions[1] = 1;
LinearGradient shader = new LinearGradient(
padding + progressHeight / 2, padding, padding + progressHeight / 2 + mDx, padding + progressHeight,
colors,
positions,
Shader.TileMode.MIRROR);
//gradient
gradientPaint.setShader(shader);
//progress line
RectF rectF = new RectF(padding + borderWidth / 2, padding + borderWidth / 2, padding + mDx + borderWidth / 2, padding + progressHeight - borderWidth / 2);
canvas.drawRoundRect(rectF, radius, radius, gradientPaint);
} else {
int progressWidth = width - padding * 2 - borderWidth;
float dx = progressWidth * percent;
progressPaint.setColor(progressColor);
RectF rectF = new RectF(padding + borderWidth / 2, padding + borderWidth / 2, padding + dx + borderWidth / 2, padding + progressHeight - borderWidth / 2);
canvas.drawRoundRect(rectF, radius, radius, progressPaint);
}
//draw second progress
if (showSecondProgress) {
float s_percent = 0;
if (max != 0) {
s_percent = secondProgress * 1.0f / max;
}
int s_progressHeight = getHeight() - padding * 2;
if (s_progressHeight % 2 != 0) {
s_progressHeight = s_progressHeight - 1;
}
if (openSecondGradient) {
int s_progressWidth = width - padding * 2;
float s_mDx = s_progressWidth * s_percent;
int s_colors[] = new int[2];
float s_positions[] = new float[2];
//from color
s_colors[0] = secondGradientFrom;
s_positions[0] = 0;
//to color
s_colors[1] = secondGradientTo;
s_positions[1] = 1;
LinearGradient s_shader = new LinearGradient(
padding + s_progressHeight / 2 + borderWidth / 2, padding + borderWidth / 2, padding + s_progressHeight / 2 + s_mDx - borderWidth / 2, padding + s_progressHeight - borderWidth / 2,
s_colors,
s_positions,
Shader.TileMode.MIRROR);
//gradient
secondGradientPaint.setShader(s_shader);
//progress line
RectF rectF = new RectF(padding + borderWidth / 2, padding + borderWidth / 2, padding + s_mDx - borderWidth / 2, padding + s_progressHeight - borderWidth / 2);
canvas.drawRoundRect(rectF, radius, radius, secondGradientPaint);
} else {
//no gradient
//line shape
int s_progressWidth = width - padding * 2;
float dx = s_progressWidth * s_percent;
secondProgressPaint.setColor(secondProgressColor);
RectF midRecf = new RectF(padding + borderWidth / 2, padding + borderWidth / 2, padding + dx - borderWidth / 2, padding + s_progressHeight - borderWidth / 2);
canvas.drawRoundRect(midRecf, radius, radius, secondProgressPaint);
}
}
}
private void drawBackground(Canvas canvas) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
//left circle
canvas.drawCircle(bgHeight / 2, bgHeight / 2, bgHeight / 2, bgPaint);
//right circle
canvas.drawCircle(width - bgHeight / 2, bgHeight / 2, bgHeight / 2, bgPaint);
//middle line
RectF midRecf = new RectF(bgHeight / 2, 0, width - bgHeight / 2, bgHeight);
canvas.drawRect(midRecf, bgPaint);
}
private void drawBorder(Canvas canvas) {
if (drawBorder) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
RectF rect = new RectF(0, 0, width, bgHeight);
canvas.drawRoundRect(rect, bgHeight / 2, bgHeight / 2, borderPaint);
}
}
private void drawBorderRect(Canvas canvas) {
if (drawBorder) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
RectF rect = new RectF(0, 0, width, bgHeight);
canvas.drawRect(rect, borderPaint);
}
}
private void drawBorderRoundRect(Canvas canvas) {
if (drawBorder) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
RectF rect = new RectF(borderWidth / 2, borderWidth / 2, width - borderWidth / 2, bgHeight - borderWidth / 2);
canvas.drawRoundRect(rect, radius, radius, borderPaint);
}
}
private void drawBackgroundRectMode(Canvas canvas) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
RectF midRecf = new RectF(0, 0, width, bgHeight);
canvas.drawRect(midRecf, bgPaint);
}
private void drawBackgroundRoundRectMode(Canvas canvas) {
int bgHeight = getHeight();
if (bgHeight % 2 != 0) {
bgHeight = bgHeight - 1;
}
int width = getWidth();
if (width % 2 != 0) {
//Fix Me
width = width - 1;
}
RectF midRecf = new RectF(borderWidth / 2, borderWidth / 2, width - borderWidth / 2, bgHeight - borderWidth / 2);
canvas.drawRoundRect(midRecf, radius, radius, bgPaint);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
getWidthAndHeight();
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
}
public int getMax() {
return max;
}
public void setMax(int max) {
this.max = max;
invalidate();
}
public double getProgress() {
return progress;
}
public void setProgress(double progress) {
if (progress < 0) {
this.progress = 0;
} else if (progress > max) {
this.progress = max;
} else {
this.progress = progress;
}
invalidate();
if (onProgressChangedListener != null) {
onProgressChangedListener.onProgressChanged(this, max, this.progress);
}
}
public boolean isShowSecondProgress() {
return showSecondProgress;
}
public void setShowSecondProgress(boolean showSecondProgress) {
this.showSecondProgress = showSecondProgress;
invalidate();
}
public int getSecondProgress() {
return secondProgress;
}
public void setSecondProgress(int secondProgress) {
if (secondProgress < 0) {
this.secondProgress = 0;
} else if (secondProgress > max) {
this.secondProgress = max;
} else {
this.secondProgress = secondProgress;
}
invalidate();
if (onProgressChangedListener != null) {
onProgressChangedListener.onSecondProgressChanged(this, max, this.secondProgress);
}
}
public int getSecondProgressShape() {
return secondProgressShape;
}
public void setSecondProgressShape(int secondProgressShape) {
this.secondProgressShape = secondProgressShape;
invalidate();
}
public int getBgColor() {
return bgColor;
}
public void setBgColor(int bgColor) {
this.bgColor = bgColor;
bgPaint.setColor(bgColor);
invalidate();
}
public boolean isOpenSecondGradient() {
return openSecondGradient;
}
public void setOpenSecondGradient(boolean openSecondGradient) {
this.openSecondGradient = openSecondGradient;
invalidate();
}
public int getSecondGradientFrom() {
return secondGradientFrom;
}
public void setSecondGradientFrom(int secondGradientFrom) {
this.secondGradientFrom = secondGradientFrom;
invalidate();
}
public int getSecondGradientTo() {
return secondGradientTo;
}
public void setSecondGradientTo(int secondGradientTo) {
this.secondGradientTo = secondGradientTo;
invalidate();
}
public int getSecondProgressColor() {
return secondProgressColor;
}
public void setSecondProgressColor(int secondProgressColor) {
this.secondProgressColor = secondProgressColor;
secondProgressPaint.setColor(secondProgressColor);
invalidate();
}
public int getProgressColor() {
return progressColor;
}
public void setProgressColor(int progressColor) {
this.progressColor = progressColor;
progressPaint.setColor(progressColor);
invalidate();
}
public int getPadding() {
return padding;
}
public void setPadding(int padding) {
this.padding = padding;
invalidate();
}
public void setShowMode(ShowMode showMode) {
switch (showMode) {
case ROUND:
this.showMode = 0;
break;
case RECT:
this.showMode = 1;
break;
case ROUND_RECT:
this.showMode = 2;
break;
}
invalidate();
}
/**
* get the percentage value of progress and max.
*
* @return percentage value
*/
public int getPercentage() {
if (max == 0) {
return 0;
}
return (int) (progress * 100.0 / max);
}
public boolean isOpenGradient() {
return openGradient;
}
public void setOpenGradient(boolean openGradient) {
this.openGradient = openGradient;
invalidate();
}
public int getGradientFrom() {
return gradientFrom;
}
public void setGradientFrom(int gradientFrom) {
this.gradientFrom = gradientFrom;
invalidate();
}
public int getGradientTo() {
return gradientTo;
}
public void setGradientTo(int gradientTo) {
this.gradientTo = gradientTo;
invalidate();
}
public void setBorderColor(int borderColor) {
this.borderColor = borderColor;
this.borderPaint.setColor(this.borderColor);
invalidate();
}
public void setGradientColor(int from, int to) {
this.gradientFrom = from;
this.gradientTo = to;
invalidate();
}
public void setSecondGradientColor(int from, int to) {
this.secondGradientFrom = from;
this.secondGradientTo = to;
invalidate();
}
public void setGradientColorAndBorderColor(int from, int to, int borderColor) {
this.gradientFrom = from;
this.gradientTo = to;
this.borderColor = borderColor;
this.borderPaint.setColor(this.borderColor);
invalidate();
}
public int getBorderColor() {
return borderColor;
}
public void setOnProgressChangedListener(OnProgressChangedListener onProgressChangedListener) {
this.onProgressChangedListener = onProgressChangedListener;
}
}
<declare-styleable name="ZzHorizontalProgressBar">
<attr name="zpb_padding" format="dimension" />
<attr name="zpb_bg_color" format="color|reference" />
<attr name="zpb_pb_color" format="color|reference" />
<attr name="zpb_second_pb_color" format="color|reference" />
<attr name="zpb_max" format="integer" />
<attr name="zpb_text" format="color|reference" />
<attr name="zpb_progress" format="integer" />
<attr name="zpb_show_zero_point" format="boolean" />
<attr name="zpb_show_second_progress" format="boolean" />
<attr name="zpb_second_progress" format="integer" />
<attr name="zpb_show_second_point_shape" format="enum">
<enum name="point" value="0" />
<enum name="line" value="1" />
</attr>
<attr name="zpb_open_gradient" format="boolean" />
<attr name="zpb_gradient_from" format="color|reference" />
<attr name="zpb_gradient_to" format="color|reference" />
<attr name="zpb_open_second_gradient" format="boolean" />
<attr name="zpb_second_gradient_from" format="color|reference" />
<attr name="zpb_second_gradient_to" format="color|reference" />
<attr name="zpb_show_mode" format="enum">
<enum name="round" value="0" />
<enum name="rect" value="1" />
<enum name="round_rect" value="2" />
</attr>
<attr name="zpb_round_rect_radius" format="dimension|reference" />
<attr name="zpb_draw_border" format="boolean" />
<attr name="zpb_border_width" format="dimension|reference" />
<attr name="zpb_border_color" format="color|reference" />
</declare-styleable>
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）