BusyWorker helps running UI tasks a separate threads (other than the JavaFX Application thread).
It will show busy cursor and disable specified nodes while task is performed.
It gives an option to show progress and status messages.
BusyWorker run tasks and takes care of handling handling exceptions and displaying error dialogs.
There is also option to perform custom finish actions after task is completed.
While task is performed property busy is set to true.
Only one task, for a given worker, can be run at the time.
When a task in being performed busyDisabledNode will be disabled and its cursor will be set to Wait/Busy cursor.
Progress and messages from the running task can be monitored using progressValue and progressMessage properties.
Below is an example of using using BusyWorker that updates a progress message and progress indicator.
The full example can be found in the BusyWorkerDemo of the ScalaFX Extras Demo project.
val buttonPane: Pane = ...
val progressLabel: Label = ...
val progressBar: ProgressBar = ...
val busyWorker = new BusyWorker("BusyWorker Demo", buttonPane) {
progressLabel.text <== progressMessage
progressBar.progress <== progressValue
}
val button = new Button("Click Me") {
onAction = () => busyWorker.doTask("Task 1")(
new SimpleTask[String] {
override def call(): String = {
val maxItems = 10
for (i <- 1 to maxItems) {
println(i)
message() = s"Processing item $i/$maxItems"
progress() = (i - 1) / 10.0
Thread.sleep(250)
}
progress() = 1
"Done"
}
}
)
}
Creates a busy worker with a title and nodes to disable when performing tasks.
The root node of the parentWindow will be disabled when task is being executed.
Creates a busy worker with a title and nodes to disable when performing tasks.
The root node of the parentWindow will be disabled when task is being executed.
The input is a collection of JavaFX or ScalaFX nodes.
val parent: Window = ...
val busyWorker = new BusyWorker("My Task", parent))
Attributes
parent
window that will be used to display dialogs (if any).
Creates a busy worker with a title and nodes to disable when performing tasks.
The root node of the parentWindow will be disabled when task is being executed.
Creates a busy worker with a title and nodes to disable when performing tasks.
The root node of the parentWindow will be disabled when task is being executed.
The input is a collection of JavaFX or ScalaFX nodes.
val parent: Option[Window] = ...
val busyWorker = new BusyWorker("My Task", parent))
Attributes
parent
window that will be used to display dialogs (if any).
Run a task on a separate thread. Returns immediately (before task is completed).
If the task returns a value is can be retrieved through the returned Future.
Run a task on a separate thread. Returns immediately (before task is completed).
If the task returns a value is can be retrieved through the returned Future.
Example of running a task without waiting to complete, using a lambda
worker.doTask{ () =>
// Some workload code, does not produce value ot it is discard
Thread.sleep(1000)
print(1 + 1)
}
Example of stating a task (with a lambda) and waiting till it finishes and returns a result
// This code will return before workload is completed
val future = worker.doTask{ () =>
// Some workload code producing final value
Thread.sleep(1000)
1 + 1
}
// This will block till workload competes and the result is retrieved
val result = future.get()
print(result)
Example of running task that updates progress and message, for more details see BusyWorkerDemo.
busyWorker.doTask(
new SimpleTask[String] {
override def call(): String = {
val maxItems = 10
for (i <- 1 to maxItems) {
println(i)
message() = s"Processing item $i/$maxItems"
progress() = (i - 1) / 10.0
Thread.sleep(250)
}
progress() = 1
"Done"
}
}
)
Attributes
task
actions to perform, can be provided a as a lambda op: => R, see examples above.
Returns:
Future that can be used to retrieve result produced the workload, if any.
Run a task on a separate thread. Returns immediately (before task is completed).
If the task returns a value is can be retrieved through the returned Future.
Run a task on a separate thread. Returns immediately (before task is completed).
If the task returns a value is can be retrieved through the returned Future.
Example of running a task without waiting to complete, using a lambda
worker.doTask("My Task") { () =>
// Some workload code, does not produce value ot it is discard
Thread.sleep(1000)
print(1 + 1)
}
Example of stating a task (with a lambda) and waiting till it finishes and returns a result
// This code will return before workload is completed
val future = worker.doTask("My Task") { () =>
// Some workload code producing final value
Thread.sleep(1000)
1 + 1
}
// This will block till workload competes and the result is retrieved
val result = future.get()
print(result)
Example of running task that updates progress and message, for more details see BusyWorkerDemo.
busyWorker.doTask("Task 1")(
new SimpleTask[String] {
override def call(): String = {
val maxItems = 10
for (i <- 1 to maxItems) {
println(i)
message() = s"Processing item $i/$maxItems"
progress() = (i - 1) / 10.0
Thread.sleep(250)
}
progress() = 1
"Done"
}
}
)
Attributes
name
name used for thread that runs the task. May be useful in debugging.
task
actions to perform, can be provided a as a lambda op: => R, see examples above.
Returns:
Future that can be used to retrieve result produced the workload, if any.
Progress indicator of a running task, if any, value are between [0 and 1].
Current running task's progress property is bound to this property (only when task is running).
Progress indicator of a running task, if any, value are between [0 and 1].
Current running task's progress property is bound to this property (only when task is running).