mordant/com.github.ajalt.mordant.animation.progress/ThreadProgressTaskAnimator

ThreadProgressTaskAnimator

interface ThreadProgressTaskAnimator<T> : BlockingAnimator, ProgressTask<T>

A BlockingAnimator for a single task.

Properties

completed

abstract val completed: Long

The number of units of work that have been completed

context

abstract val context: T

The context is used to pass custom information to the task

finished

abstract val finished: Boolean

true if this animation has finished and should be stopped or cleared.

fps

open val fps: Int

The rate, in Hz, that this animation should be refreshed, or 0 if it should not be refreshed automatically.

abstract val id: TaskId

The unique id of this task

paused

abstract val paused: Boolean

Whether the task is currently paused

refreshPeriod

val RefreshableAnimation.refreshPeriod: Duration

The time between refreshes. This is 1 / refreshRate

started

abstract val started: Boolean

Whether the task has been started

total

abstract val total: Long?

The total number of units of work, or null if the total is unknown

visible

abstract val visible: Boolean

Whether the task should be visible in the progress bar

Functions

advance

fun ProgressTask<*>.advance(amount: Long = 1)

fun ProgressTask<*>.advance(amount: Number)

Advance the completed progress of this task by amount.

animateOnThread

fun RefreshableAnimation.animateOnThread(terminal: Terminal): BlockingAnimator

Create an animator that runs this animation synchronously.

clear

abstract override fun clear()

Stop this animation and remove it from the screen.

execute

fun BlockingAnimator.execute(executor: ExecutorService = Executors.newSingleThreadExecutor(DaemonThreadFactory())): Future<*>

Run the animation in a background thread on an executor.

makeState

abstract fun makeState(): ProgressState<T>

Create a ProgressState for this task's current state

refresh

abstract fun refresh(refreshAll: Boolean = false)

Draw the animation to the screen.

reset

abstract fun reset(start: Boolean = true, block: ProgressTaskUpdateScope<T>.() -> Unit = {})

Reset the task so its completed count is 0 and its clock is reset.

runBlocking

abstract fun runBlocking()

Start the animation and refresh it until all its tasks are finished.

stop

abstract override fun stop()

Stop this animation without removing it from the screen.

update

abstract fun update(block: ProgressTaskUpdateScope<T>.() -> Unit)

Update the task's state.

update

fun ProgressTask<*>.update(completed: Long)

fun ProgressTask<*>.update(completed: Number)

Set the completed progress of this task to completed.