使用ProgressBar

This commit is contained in:
HapeLee committed 2025-09-05 03:38:27 +08:00
1 parent 3b10cb7ad7
commit ee703523de
24 files changed
+54 -463

No files matched your search

@@ -1,195 +0,0 @@
package io.legato.kazusa.ui.widget.anima
import android.content.Context
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Rect
import android.graphics.RectF
import android.os.Looper
import android.util.AttributeSet
import android.view.View
import io.legato.kazusa.R
@Suppress("unused", "MemberVisibilityCanBePrivate")
class RefreshProgressBar @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null
) : View(context, attrs) {
private var a = 1
private var durProgress = 0
private var secondDurProgress = 0
var maxProgress = 100
var secondMaxProgress = 100
var bgColor = 0x00000000
var secondColor = -0x3e3e3f
var fontColor = -0xc9c9ca
var speed = 2
var secondFinalProgress = 0
private set
private var paint: Paint = Paint()
private val bgRect = Rect()
private val secondRect = Rect()
private val fontRectF = RectF()
var isAutoLoading: Boolean = false
set(loading) {
field = loading
if (!loading) {
secondDurProgress = 0
secondFinalProgress = 0
}
maxProgress = 0
invalidate()
}
init {
paint.style = Paint.Style.FILL
val a = context.obtainStyledAttributes(attrs, R.styleable.RefreshProgressBar)
speed = a.getDimensionPixelSize(R.styleable.RefreshProgressBar_speed, speed)
maxProgress = a.getInt(R.styleable.RefreshProgressBar_max_progress, maxProgress)
durProgress = a.getInt(R.styleable.RefreshProgressBar_dur_progress, durProgress)
secondDurProgress = a.getDimensionPixelSize(
R.styleable.RefreshProgressBar_second_dur_progress,
secondDurProgress
)
secondFinalProgress = secondDurProgress
secondMaxProgress = a.getDimensionPixelSize(
R.styleable.RefreshProgressBar_second_max_progress,
secondMaxProgress
)
bgColor = a.getColor(R.styleable.RefreshProgressBar_bg_color, bgColor)
secondColor = a.getColor(R.styleable.RefreshProgressBar_second_color, secondColor)
fontColor = a.getColor(R.styleable.RefreshProgressBar_font_color, fontColor)
a.recycle()
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
paint.color = bgColor
bgRect.set(0, 0, measuredWidth, measuredHeight)
canvas.drawRect(bgRect, paint)
if (secondDurProgress > 0 && secondMaxProgress > 0) {
var secondDur = secondDurProgress
if (secondDur > secondMaxProgress) {
secondDur = secondMaxProgress
}
paint.color = secondColor
val tempW =
(measuredWidth.toFloat() * 1.0f * (secondDur * 1.0f / secondMaxProgress)).toInt()
secondRect.set(
measuredWidth / 2 - tempW / 2,
0,
measuredWidth / 2 + tempW / 2,
measuredHeight
)
canvas.drawRect(secondRect, paint)
}
if (durProgress > 0 && maxProgress > 0) {
paint.color = fontColor
fontRectF.set(
0f,
0f,
measuredWidth.toFloat() * 1.0f * (durProgress * 1.0f / maxProgress),
measuredHeight.toFloat()
)
canvas.drawRect(fontRectF, paint)
}
if (this.isAutoLoading) {
if (secondDurProgress >= secondMaxProgress) {
a = -1
} else if (secondDurProgress <= 0) {
a = 1
}
secondDurProgress += a * speed
if (secondDurProgress < 0)
secondDurProgress = 0
else if (secondDurProgress > secondMaxProgress)
secondDurProgress = secondMaxProgress
secondFinalProgress = secondDurProgress
invalidate()
} else {
if (secondDurProgress != secondFinalProgress) {
if (secondDurProgress > secondFinalProgress) {
secondDurProgress -= speed
if (secondDurProgress < secondFinalProgress) {
secondDurProgress = secondFinalProgress
}
} else {
secondDurProgress += speed
if (secondDurProgress > secondFinalProgress) {
secondDurProgress = secondFinalProgress
}
}
this.invalidate()
}
}
}
fun getDurProgress(): Int {
return durProgress
}
fun setDurProgress(durProgress: Int) {
var durProgress1 = durProgress
if (durProgress1 < 0) {
durProgress1 = 0
}
if (durProgress1 > maxProgress) {
durProgress1 = maxProgress
}
this.durProgress = durProgress1
if (Looper.myLooper() == Looper.getMainLooper()) {
this.invalidate()
} else {
this.postInvalidate()
}
}
fun getSecondDurProgress(): Int {
return secondDurProgress
}
fun setSecondDurProgress(secondDur: Int) {
this.secondDurProgress = secondDur
this.secondFinalProgress = secondDurProgress
if (Looper.myLooper() == Looper.getMainLooper()) {
this.invalidate()
} else {
this.postInvalidate()
}
}
fun setSecondDurProgressWithAnim(secondDur: Int) {
var secondDur1 = secondDur
if (secondDur1 < 0) {
secondDur1 = 0
}
if (secondDur1 > secondMaxProgress) {
secondDur1 = secondMaxProgress
}
this.secondFinalProgress = secondDur1
if (Looper.myLooper() == Looper.getMainLooper()) {
this.invalidate()
} else {
this.postInvalidate()
}
}
fun clean() {
durProgress = 0
secondDurProgress = 0
secondFinalProgress = 0
if (Looper.myLooper() == Looper.getMainLooper()) {
this.invalidate()
} else {
this.postInvalidate()
}
}
}
@@ -1,228 +0,0 @@
package io.legato.kazusa.ui.widget.anima
import android.animation.Animator
import android.animation.AnimatorListenerAdapter
import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.graphics.RectF
import android.util.AttributeSet
import android.view.View
import io.legato.kazusa.R
//import io.legado.app.lib.theme.accentColor
import io.legato.kazusa.utils.dpToPx
/**
* RotateLoading
* Created by Victor on 2015/4/28.
*/
@Suppress("MemberVisibilityCanBePrivate")
class RotateLoading @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null
) : View(context, attrs) {
private var mPaint: Paint
private var loadingRectF: RectF? = null
private var shadowRectF: RectF? = null
private var topDegree = 10
private var bottomDegree = 190
private var arc: Float = 0.toFloat()
private var thisWidth: Int = 0
private var changeBigger = true
private var shadowPosition: Int = 0
private var hideMode = GONE
var isStarted = false
private set
var loadingColor: Int = 0
set(value) {
field = value
invalidate()
}
private var speedOfDegree: Int = 0
private var speedOfArc: Float = 0.toFloat()
private val shown = Runnable { this.startInternal() }
private val hidden = Runnable { this.stopInternal() }
init {
//loadingColor = context.accentColor
thisWidth = DEFAULT_WIDTH.dpToPx()
shadowPosition = DEFAULT_SHADOW_POSITION.dpToPx()
speedOfDegree = DEFAULT_SPEED_OF_DEGREE
if (null != attrs) {
val typedArray = context.obtainStyledAttributes(attrs, R.styleable.RotateLoading)
loadingColor =
typedArray.getColor(R.styleable.RotateLoading_loading_color, loadingColor)
thisWidth = typedArray.getDimensionPixelSize(
R.styleable.RotateLoading_loading_width,
DEFAULT_WIDTH.dpToPx()
)
shadowPosition = typedArray.getInt(
R.styleable.RotateLoading_shadow_position,
DEFAULT_SHADOW_POSITION
)
speedOfDegree =
typedArray.getInt(R.styleable.RotateLoading_loading_speed, DEFAULT_SPEED_OF_DEGREE)
typedArray.recycle()
}
speedOfArc = (speedOfDegree / 4).toFloat()
mPaint = Paint()
mPaint.color = loadingColor
mPaint.isAntiAlias = true
mPaint.style = Paint.Style.STROKE
mPaint.strokeWidth = thisWidth.toFloat()
mPaint.strokeCap = Paint.Cap.ROUND
}
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
super.onSizeChanged(w, h, oldw, oldh)
arc = 10f
loadingRectF =
RectF(
(2 * thisWidth).toFloat(),
(2 * thisWidth).toFloat(),
(w - 2 * thisWidth).toFloat(),
(h - 2 * thisWidth).toFloat()
)
shadowRectF = RectF(
(2 * thisWidth + shadowPosition).toFloat(),
(2 * thisWidth + shadowPosition).toFloat(),
(w - 2 * thisWidth + shadowPosition).toFloat(),
(h - 2 * thisWidth + shadowPosition).toFloat()
)
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
if (!isStarted) {
return
}
mPaint.color = Color.parseColor("#1a000000")
shadowRectF?.let {
canvas.drawArc(it, topDegree.toFloat(), arc, false, mPaint)
canvas.drawArc(it, bottomDegree.toFloat(), arc, false, mPaint)
}
mPaint.color = loadingColor
loadingRectF?.let {
canvas.drawArc(it, topDegree.toFloat(), arc, false, mPaint)
canvas.drawArc(it, bottomDegree.toFloat(), arc, false, mPaint)
}
topDegree += speedOfDegree
bottomDegree += speedOfDegree
if (topDegree > 360) {
topDegree -= 360
}
if (bottomDegree > 360) {
bottomDegree -= 360
}
if (changeBigger) {
if (arc < 160) {
arc += speedOfArc
invalidate()
}
} else {
if (arc > speedOfDegree) {
arc -= 2 * speedOfArc
invalidate()
}
}
if (arc >= 160 || arc <= 10) {
changeBigger = !changeBigger
invalidate()
}
}
override fun onAttachedToWindow() {
super.onAttachedToWindow()
if (visibility == VISIBLE) {
startInternal()
}
}
override fun onDetachedFromWindow() {
super.onDetachedFromWindow()
isStarted = false
animate().cancel()
removeCallbacks(shown)
removeCallbacks(hidden)
}
fun visible() {
removeCallbacks(shown)
removeCallbacks(hidden)
post(shown)
}
fun inVisible() {
hideMode = INVISIBLE
removeCallbacks(shown)
removeCallbacks(hidden)
stopInternal()
}
fun gone() {
hideMode = GONE
removeCallbacks(shown)
removeCallbacks(hidden)
stopInternal()
}
private fun startInternal() {
startAnimator()
isStarted = true
invalidate()
}
private fun stopInternal() {
stopAnimator()
invalidate()
}
private fun startAnimator() {
animate().cancel()
animate().scaleX(1.0f)
.scaleY(1.0f)
.setListener(object : AnimatorListenerAdapter() {
override fun onAnimationStart(animation: Animator) {
visibility = VISIBLE
}
})
.start()
}
private fun stopAnimator() {
animate().cancel()
isStarted = false
this.visibility = hideMode
}
companion object {
private const val DEFAULT_WIDTH = 6
private const val DEFAULT_SHADOW_POSITION = 2
private const val DEFAULT_SPEED_OF_DEGREE = 10
}
}