Examples Widgets Progress Bar

This example will show how to use the progress bar in different ways. We'll set progress manually, have it update on button click, have it update from a recurring scheduled task, and have it update from a background thread.

- Layout:
    mode: table
    orientation: lr-tb
    cols: 2
    border: true

    // This is a regular progressbar. We'll set its value manually.
    - Label:
        text: Static
        auto_scale: true, true
        size_hint_x: 0.5
        halign: center
        valign: middle
    - Layout:
        size_hint_x: 0.5
        auto_scale_height: true
        - ProgressBar:
            id: static_progress_bar
            size_hint_x: none
            width: parent.width - parent.static_label.width
            max: 100
            value: 50
            border: true
        - Label:
            id: static_label
            text: parent.static_progress_bar.value
            size_hint_x: none
            width: 4
            auto_scale_height: true
            valign: middle

    // We'll bind a callback to this progress bar to update on button press
    - Button:
        id: manual_button
        fg_color: yellow
        text: Increase
        size_hint_x: 0.5
        auto_scale_height: true
    - Layout:
        auto_scale_height: true
        size_hint_x: 0.5
        - ProgressBar:
            id: manual_progress_bar
            size_hint_x: none
            width: parent.width - parent.manual_label.width
            border: true
        - Label:
            id: manual_label
            text: parent.manual_progress_bar.value
            size_hint_x: none
            width: 4
            auto_scale_height: true
            valign: middle

    // We'll bind a callback to update the value with a recurring task
    - Button:
        id: task_button
        fg_color: yellow
        text: Start task
        size_hint_x: 0.5
        auto_scale_height: true
    - Layout:
        size_hint_x: 0.5
        auto_scale_height: true
        - ProgressBar:
            id: task_progress_bar
            size_hint_x: none
            width: parent.width - parent.task_label.width
            border: true
        - Label:
            id: task_label
            text: parent.task_progress_bar.value
            size_hint_x: none
            width: 4
            auto_scale_height: true
            valign: middle

    // We'll bind a callback to update the value from a background thread
    - Button:
        id: thread_button
        fg_color: yellow
        text: Start thread
        size_hint_x: 0.5
        auto_scale_height: true
    - Layout:
        size_hint_x: 0.5
        auto_scale_height: true
        - ProgressBar:
            id: thread_progress_bar
            size_hint_x: none
            width: parent.width - parent.thread_label.width
            border: true
        - Label:
            id: thread_label
            text: parent.thread_progress_bar.value
            size_hint_x: none
            width: 4
            auto_scale_height: true
            valign: middle

use std::time::Duration;
use ez_term::*;

fn main () {
    let (root_widget, mut state_tree, mut scheduler) = load_ui();

    // Manual progress bar callback
    let manual_progress_callback = |context: Context| {
        let state = context.state_tree.get_mut("manual_progress_bar")
            .as_progress_bar_mut();
        let progress = state.get_value();
        if progress < state.get_max() {
            state.set_value(progress + 20);
            state.update(context.scheduler);
            if state.get_value() == state.get_max() {
                let state = context.state_tree.get_mut("manual_button").as_button_mut();
                state.set_disabled(true);
            }
        }
        false

    };
    let callback_config =
        CallbackConfig::from_on_press(Box::new(manual_progress_callback));
    scheduler.update_callback_config("manual_button", callback_config);

    // Recurring task progress bar callback
    let task_progress_callback = |context: Context| {

        let task_progress_task = |context: Context| {
            let state = context.state_tree.get_mut("task_progress_bar")
                .as_progress_bar_mut();
            let progress = state.get_value();
            if progress < state.get_max() {
                state.set_value(progress + 20);
                state.update(context.scheduler);
                true
            } else {
                let state = context.state_tree.get_mut("task_button").as_button_mut();
                state.set_disabled(false);
                state.update(context.scheduler);
                false
            }
        };
        let state = context.state_tree.get_mut("task_progress_bar")
            .as_progress_bar_mut();
        state.set_value(0);
        let state = context.state_tree.get_mut("task_button").as_button_mut();
        state.set_disabled(true);
        state.update(context.scheduler);
        context.scheduler.schedule_recurring("update_progress_bar",
                                     Box::new(task_progress_task),
                                     Duration::from_secs(1));
        false
    };
    let callback_config =
        CallbackConfig::from_on_press(Box::new(task_progress_callback));
    scheduler.update_callback_config("task_button", callback_config);

    // Threaded task progress bar callback
    let thread_progress_callback = |context: Context| {

        let progress_thread = |mut context: ThreadedContext| {
            let state = context.state_tree.get_mut("thread_progress_bar")
                .as_progress_bar_mut();
            state.set_value(0);
            state.update(&mut context.scheduler);
            for x in 1..=5 {
                std::thread::sleep(Duration::from_secs(1));
                state.set_value(x * 20);
                state.update(&mut context.scheduler);
            }
        };
        let on_finish = |context: Context| {
            let state = context.state_tree.get_mut("thread_button").as_button_mut();
            state.set_disabled(false);
            state.update(context.scheduler);
        };
        let state = context.state_tree.get_mut("thread_button").as_button_mut();
        state.set_disabled(true);
        state.update(context.scheduler);
        context.scheduler.schedule_threaded(Box::new(progress_thread),
                                     Some(Box::new(on_finish)));
        false
    };
    let callback_config =
        CallbackConfig::from_on_press(Box::new(thread_progress_callback));
    scheduler.update_callback_config("thread_button", callback_config);

    run(root_widget, state_tree, scheduler);