How can I update ProgressIndicator progress with Rust

[HustWu]

I want to update progress in my rust program with a new thread.

But I meet a problem that I can not share the window between the main thread and the son thread. Here is my program.

main.rs

#![allow(unused)]
slint::include_modules!();
use std::collections::btree_map::Range;
use std::sync::mpsc;
use std::time::Duration;
// extern crate console_error_panic_hook;
use std::{panic, result, string};
use std::{rc::Rc, process::Command};  
use rand::Error;
use ssh2::{Session, Channel};
use std::io::Read;
use log4rs;
// use log::warn;
use slint::{StandardListViewItem, VecModel, SharedString, Weak}; 
use std::fs;
use log::{info, warn};
use std::thread;

// #[cfg_attr(target_arch = "wasm32",
//            wasm_bindgen::prelude::wasm_bindgen(start))]

// fn update_process(window : &MainWindow) { 
//     let handle = thread::spawn( move || {
//         for i in 0..10  {
//         thread::sleep(Duration::from_secs(1));
//             window.set_testprogress(i);   
//         }    
//     });
// }

fn main() {  
    let support_disk_list = ["nvme0n1", "nvme1n1", "sda", "sdb"];
    log4rs::init_file("log4rs.yaml", Default::default()).unwrap();
    // panic::set_hook(Box::new(console_error_panic_hook::hook));
    let window = MainWindow::new().unwrap();  
    // 全局单例中的回调（带参数和返回值）  
    window.global::<Logic>().on_to_upper_case(|string| {  
        string.as_str().to_uppercase().into()  
    });  
// create thread and update progress
    let main_window_weak = window.as_weak();
    let mut startupdate = true;
    let thread = std::thread::spawn(move || {
        let main_window = main_window_weak.unwrap();
        while startupdate {
            if main_window.get_startrecord(){
                for i in 0..100  {
                    thread::sleep(Duration::from_secs(1));
                    main_window_weak.upgrade_in_event_loop(move | window: MainWindow | window.set_testprogress(i));

                    if i == 99 {
                        startupdate = false;
                    }
                } 
            }                
        }
    });   
    let main_window_weak = window.as_weak();  
    window.on_button_pressed(move || {
        info!("Start button click!");
        let tiles_model: Rc<VecModel<StandardListViewItem>> = Rc::new(VecModel::default());   
        let main_window = main_window_weak.unwrap();  
        main_window.set_getsmart(true); 
        let command = "smartctl --scan";
        let output: std::process::Output = Command::new("Cmd").args(&["/C", command]).output().unwrap();
        info!("Get smart device finish!");
        let stdout = String::from_utf8_lossy(&output.stdout);
        let words: Vec<&str> = stdout.split(' ').collect();
        for value in &words {
            info!("the element is {}", value);
        }
        let smart_command = "smartctl -i ";
        let smart_output = Command::new("Cmd").args(&["/C", &(smart_command.to_string() + words[0])]).output().unwrap();
        info!("Get smart info finish!");
        let stdout = String::from_utf8_lossy(&smart_output.stdout);
        let smart_words: Vec<&str> = stdout.split('\n').collect();
        for (index, value) in smart_words.iter().enumerate() {
            if index >= 4 && index <= 9 {
                info!("the element is {}", value);
                tiles_model.push(slint::format!("{value}").into())
            }        
        }
        main_window.set_isConnect(true);
        main_window.global::<ListViewPageAdapter>().set_devicelist(true);
        main_window.global::<ListViewPageAdapter>().set_smartbutton(true);
        main_window.global::<ListViewPageAdapter>().set_list_data(tiles_model.clone().into());  
    });  

    let main_window_weak = window.as_weak(); 
    window.on_starttest_pressed(move || {
        let main_window = main_window_weak.unwrap();
        main_window.set_startrecord(true)
    });

    // connect window
    let main_window_weak = window.as_weak(); 
    window.on_connect_pressed(move || {
        let main_window = main_window_weak.unwrap();  
        if !(main_window.get_isRemote() || main_window.get_isLocal()) {
            warn!("No Test Mode Select!");
        }
        else if main_window.get_isLocal() {
            let tiles_model: Rc<VecModel<StandardListViewItem>> = Rc::new(VecModel::default());
            let command = "smartctl --scan";
            let output: std::process::Output = Command::new("Cmd").args(&["/C", command]).output().unwrap();
            info!("Get smart device finish!");
            let stdout = String::from_utf8_lossy(&output.stdout);
            let words: Vec<&str> = stdout.split(' ').collect();

            let tiles_model: Rc<VecModel<SharedString>> = Rc::new(VecModel::default());
            tiles_model.push(slint::format!("Select one device").into());  
            for disk in words {
                let mut info: Vec<&str> = disk.split("/").collect();
                let device = info[info.len() - 1];
                if support_disk_list.contains(&device) {
                    tiles_model.push(slint::format!("{device}").into());
                };
            };
            main_window.global::<ListViewPageAdapter>().set_device_info(tiles_model.clone().into());       
        }
        else if  main_window.get_isRemote() {
            if format!("{}", &(main_window.get_host())) == " " {
                warn!("ip error!");
                return;
            }
            let tcp = std::net::TcpStream::connect(format!("{}:22", &(main_window.get_host()))).unwrap();
            let mut sess = Session::new().unwrap();
            sess.set_tcp_stream(tcp);
            match sess.handshake() {
                Ok(result) =>{
                    0;
                }
                Err(e) =>{
                    warn!("ip {} error {}", &(main_window.get_host()), e);
                    return;
                }
            };
            // Authenticate with SSH server
            match sess.userauth_password(&(main_window.get_user()), &(main_window.get_pwd())) {
                Ok(result) =>{
                    0;
                }
                Err(e) =>{
                    warn!("password or user wrong error {}", e);
                    return;
                }
            };
            let result = sess.channel_session();
            match result {
                Ok(channel) =>{
                    main_window.set_isConnect(true);
                    info!("Connect Host {}, user {}, password {}", &(main_window.get_host()), &(main_window.get_user()), &(main_window.get_pwd()));
                    let mut channel  = sess.channel_session().unwrap();
                    channel.exec("lsblk").unwrap();
                    let mut s = String::new();
                    channel.read_to_string(&mut s).unwrap();
                    let disk_infos:Vec<&str> = s.split("\n").collect();
                    let tiles_model: Rc<VecModel<SharedString>> = Rc::new(VecModel::default());
                    tiles_model.push(slint::format!("Select one device").into());  
                    for disk in disk_infos {
                        let mut info: Vec<&str> = disk.split(" ").collect();
                        let device = info[0];
                        if support_disk_list.contains(&device) {
                            tiles_model.push(slint::format!("{device}").into());
                        };
                    };
                    main_window.global::<ListViewPageAdapter>().set_device_info(tiles_model.clone().into());  
                }
                Err(e) =>{
                    main_window.set_isConnect(false);
                    warn!("Connect error {}", e);
                }            
            }
        }
    });

    let tiles_model: Rc<VecModel<StandardListViewItem>> = Rc::new(VecModel::default());  
    for r in 1..=100 { // 100行  
        tiles_model.push(slint::format!("Item {r}").into()); 
    } 
    window.global::<ListViewPageAdapter>().set_list_data(tiles_model.clone().into());  
    // 运行窗体  
    window.run().unwrap();  
}

main.slint

import { GroupBox, HorizontalBox, VerticalBox, StandardListView, LineEdit, Button, Switch, ComboBox , CheckBox, ProgressIndicator} from "std-widgets.slint";  
    
// 导出全局单单例  
export global Logic {  
    // You can collect other global properties here  
    in-out property <int> counter: 0; 
    // 全局单例中的回调（带参数和返回值）  
    pure callback to-upper-case(string) -> string;  
}  

// 对外导出全局单例（可与 Rust 代码直接交互）  
export global ListViewPageAdapter  {  
    // StandardListView model (in StandardListViewItem): The model  
    in property <[StandardListViewItem]> list_data: [  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
    ]; 
    
    in property <[string]> device_info:[
        "Select Something", "Example1", "Example2",  
    ];
    in-out property <bool> devicelist;
    in-out property <bool> smartbutton;
}  
    
export component MainWindow inherits Window {  
    preferred-width: 550px;  
    preferred-height: 300px;  

    in-out property <int> counter: 0; //in-out类型的属性  
    in-out property <bool> getsmart: true;
    in-out property <bool> isConnect: false; 
    in-out property <string> host <=> hostip.text;
    in-out property <string> user <=> username.text;
    in-out property <string> pwd <=> password.text;
    out property <bool> isRemote <=> remote.checked;
    out property <bool> isLocal <=> local.checked;
    in-out property <bool> startrecord :false;
    in-out property <int> testprogress: 0;


    callback button-pressed <=> button.clicked; // 双向绑定属性的回调  
    callback connect-pressed <=> connect.clicked;
    callback cancel-pressed <=> cancel.clicked;
    callback starttest-pressed <=> starttest.clicked;

    VerticalBox {  
        alignment: start;  
        GroupBox {
            title: @tr("选择执行测试的设备");            
            vertical-stretch: 0;
            
            VerticalBox {
                padding: 0px;
                spacing: 2px;
                HorizontalBox {  
                    HorizontalBox {
                        alignment: start;
                        remote := CheckBox {
                            text: @tr("Remote");
                            checked: false;
                            enabled: local.checked ? false : true;
                        }
    
                        local := CheckBox {
                            text: @tr("Local");
                            checked: false;
                            enabled: remote.checked ? false : true;
                        }
                    }
                    HorizontalBox {
                        alignment: end;
                        connect := Button{
                            height:30px;  
                            // 属性绑定  
                            text: "Connect";
                            enabled: !isConnect ? true : false;
                        }
    
                        cancel := Button{
                            height:30px;  
                            // 属性绑定  
                            text: "Cancel";
                            enabled: true;
                            clicked => {
                                ListViewPageAdapter.device_info = ["Select Something", "Example1", "Example2"];
                                isConnect = false;
                            }
                        }
                    }
                }
    
                HorizontalBox {
                    alignment: start;
                    padding: 0px;
                    spacing: 25px;
        
                    hostip := LineEdit {
                        placeholder-text: @tr("Enter host ip");
                        enabled: !isConnect && remote.checked ? true : false;
                    }
                    username := LineEdit {
                        placeholder-text: @tr("Enter user name");
                        enabled: !isConnect && remote.checked? true : false;
                    }
    
                    password := LineEdit {
                        placeholder-text: @tr("Enter password");
                        enabled: !isConnect && remote.checked ? true : false;
                    }
                }
            }
        } 

        GroupBox {
            title: @tr("Device Select");
            vertical-stretch: 0;

    
            HorizontalBox {
                alignment: start;
                padding: 0px;
    
                devicelist := ComboBox {
                    model: ListViewPageAdapter.device-info;
                    enabled: true;
                }

                button := Button {  
                    height:30px;  
                    // 属性绑定  
                    text: "Get Smart Info"; 
                    enabled: true;
                }  
            }
        }

        GroupBox {  
            title: @tr("Test Control");  
            VerticalBox {
                alignment: start;              
                starttest := Button {  
                    width: 50px;
                    height:30px;  
                    // 属性绑定  
                    text: "Start"; 
                    enabled: true;
                    clicked => {
                        startrecord = true;
                    }
                } 
    
                testprocess := ProgressIndicator {
                    width: 100%;
                    height: 20px;
                    progress: testprogress / 100;
                    indeterminate: false;
                }
            }

        }
    }  
}  

[ogoffart]

You can send the weak to an different thread, and then use upgrade_in_event_loop.
See the example of: https://docs.rs/slint/latest/slint/struct.Weak.html#method.upgrade_in_event_loop

[HustWu]

Can I get widgets value in the thread?

[ogoffart]

You need to get them in the main thread and send them to the thread, or from a upgrade_in_event_loop closure.

[HustWu]

Thanks for the reply.

In the second way, Did you mean, I get the widgets value outside the thread, and capture it in the closure?

[HustWu]

I can not use 'upgrade_in_event_loop' to update StandardListViewItem, but I have to update the table value, is there any way?

main.slint

export global ListViewPageAdapter  {  
    // StandardListView model (in StandardListViewItem): The model  
    in property <[StandardListViewItem]> list_data: [  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
        {text: "Lorem"}, {text: "ipsum"},{text: "dolor"},{text: "sit"},{text: "amet"},{text: "consetetur"},  
    ]; 

    in-out property <[[StandardListViewItem]]> test_data:[  
        [{text: "Lorem"}, {text: "ipsum"}, {text: "dolor"}, {text: "sit"}],
        [{text: "dolor"}, {text: "sit"}, {text: "dolor"}, {text: "sit"}],  
    ];
    
    in property <[[StandardListViewItem]]> disk_info:[  
        [{text: "Lorem"}, {text: "ipsum"}],
        [{text: "dolor"}, {text: "sit"}],
        [{text: "amet"}, {text: "consetetur"}],  
    ]; 
    
    in property <[string]> device_info:[
        "Select Something", "Example1", "Example2",  
    ];
    in-out property <bool> devicelist;
    in-out property <bool> smartbutton;
} 

main.rs

tmp_window_weak.upgrade_in_event_loop(move | window | window.global::<ListViewPageAdapter>().set_test_data(row_data.clone().into()));  

[ogoffart]

I am not sure I understand your question.
Yes, your code seems alright.