Android 自定义横向进度条_android自定义横向进度条-程序员宅基地
Android 自定义横向进度条
一、工具类如下代码，可自定义进度条背景色，边框颜色，进度值设置等
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;
}
}
二、把下面代码拷贝到styles文件中
<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>
三、效果图如下：
资源下载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
智能推荐
芋道 Spring Boot JPA 入门-程序员宅基地
文章浏览阅读230次。点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析..._芋道源怎么使用orderby
uni-app 之 解决u-button始终居中问题-程序员宅基地
文章浏览阅读881次。uni-app 之 解决u-button始终居中问题_u-button
Faster RCNN原理篇（三）——区域候选网络RPN（Region Proposal Network）的学习、理解-程序员宅基地
文章浏览阅读1w次，点赞57次，收藏170次。区域候选网络RPN（Region Proposal Network）的学习、理解Anchors详解`generate_anchors.py`文件中generate_anchors函数源码解读Anchor的产生过程：RPN（Region Proposal Network）：它是首先在Faster RCNN中提出的，其 核心功能： 1. 得到用来预测的feature map。 具体而言：图像在输入网络后，依次经过一系列卷积+ReLU得到了51×39×25651×39×25651×39×256维的featu_region proposal
lucene倒排索引表搜索原理_lucene 倒排表 时间复杂度-程序员宅基地
文章浏览阅读3.9k次，点赞2次，收藏13次。什么是正排索引？什么是倒排索引？搜索的过程是什么样的？会用到哪些算法与数据结构？ 前面的内容太宏观，为了照顾大部分没有做过搜索引擎的同学，数据结构与算法部分从正排索引、倒排索引一点点开始。提问：什么是正排索引（forward index）？回答：由key查询实体的过程，是正排索引。用户表：t_user(uid, name, passwd, age, sex)，由uid查询整行的过程，就是正排索引查..._lucene 倒排表 时间复杂度
kibana数据源定义_定义攻击数据源第一部分-程序员宅基地
文章浏览阅读789次。kibana数据源定义Discussion around ATT&CK often involves tactics, techniques, procedures, detections, and mitigations, but a significant element is often overlooked: data sources. Data sources for every..._kibana 数据源
R 笔记_r语言adaboost.m1-程序员宅基地
文章浏览阅读2.6k次，点赞3次，收藏15次。包含命令以及简单的文字说明，巩固记忆，并方便以后检索，包含调用方式一些简短说明。经历包括包括《R语言与机器学习》，夹杂一些《R语言实战》以及参考一些网络大神的博客。关于model的summary的说明：星号（***）表示预测能力，显著性水平，星号越多，显著性水平越低，相关的可能越小。多元R方值（判定系数）代表着从整体上，模型能多大程度上解释因变量的值，类似于相关系数。F检验：线性模型输出显示中的F_r语言adaboost.m1
随便推点
Oracle over函数-程序员宅基地
文章浏览阅读535次。Oracle over函数SQL code: sql over的作用及用法RANK ( ) OVER ( [query_partition_clause] order_by_clause )DENSE_RANK ( ) OVER ( [query_partition_clause] order_by_clause )可实现按指定的字段分组排序，对于相同分组字段的结果集进
深入了解Netty【八】TCP拆包、粘包和解决方案_粘包 八个一组-程序员宅基地
文章浏览阅读250次。1、TCP协议传输过程TCP协议是面向流的协议，是流式的，没有业务上的分段，只会根据当前套接字缓冲区的情况进行拆包或者粘包：发送端的字节流都会先传入缓冲区，再通过网络传入到接收端的缓冲区中，最终由接收端获取。2、TCP粘包和拆包概念因为TCP会根据缓冲区的实际情况进行包的划分，在业务上认为，有的包被拆分成多个包进行发送，也可能多个晓小的包封装成一个大的包发送，这就是TCP..._粘包 八个一组
苹果7plus元件分布图_苹果iPhone7Plus元件分布图+电路原理图+位置图PDF-程序员宅基地
文章浏览阅读6k次。苹果iPhone7Plus元件分布图+电路原理图+点位图(PDF格式)高通版_ALL_ BOARD _V1 PDF点位图(非PCB格式)iPhone 7P D11 MLB电路原理图.pdfiPhone 7P PCB Layout.pdf元器件彩图A.jpg元器件彩图B.jpgiphone7p D11高通基带 电路原理图-全.pdfBRD_820-00229.pdfA10 cpu中层阻值图+供电图...._苹果7p芯片位置图
No.1 STM32F429IGT6开发板简介 （STM32F429/F767/H743）_stm32f429igt6中文说明-程序员宅基地
文章浏览阅读7k次，点赞13次，收藏55次。新购入一块开发板 正点原子的STM32F429核心板+底板写这个 专栏博客 STM32F429专栏 记录学习这块板子的全过程 持续更新有兴趣的UU们一起来学习吧 对于没学过有兴趣想学习STM32的UU有什么不清楚可以私信我接下来一起开启学习之旅吧硬件平台正点原子STM32F429软件平台正点原子和野火视频教程正点原子 寄存器/HAL库代码和野火 固件标准库代码&还有自写代码开发板底板鸟瞰图：核心板鸟瞰图：MCU丝印型号详解：总线架构：存储器映射：存储_stm32f429igt6中文说明
1.2亿次下载，近3万Star的开源项目是为何会“死”掉？-程序员宅基地
文章浏览阅读2.7k次。整理 | 孙胜 出品 | CSDN（ID：CSDNnews）Faker 是一个流行的模拟数据生成库，程序员只需简单地几步操作，就可以在浏览器和 Node.js 中生成大量的假数..._1.2亿次下载,近3万star的开源项目是为何会“死”掉?
sol2 二 教程：快速入门-程序员宅基地
文章浏览阅读3.5k次。断言 / 先决条件你需要在代码中包含#include<sol/sol.hpp> ，这只是一个头文件，不需要编译，但是你的lua 必须是编译可用的。断言如下：#ifndef EXAMPLES_ASSERT_HPP#define EXAMPLES_ASSERT_HPP# define m_assert(condition, message) \ do { \ if (! (condition)) { \ std::ce..._sol2