Banging my head against this

[Tsuiban]

Ok, trying to write something with slint in Rust, and utterly frustrated with it.

1. It seems that I need to create a weak reference for EACH callback, so multiple variables instead of one single one.
2. I have a few LineEdit fields that, supposedly, take their values from a property and, theoretically, should be putting edited values back into those properties - and yet that doesn't seem to be happening. The properties remain blank.

so in my main code I have something resembling:

main.rs:

...
let ui = AppWindow::new();
let ui_1 = ui.as_weak();
let ui_2 = ui.as_weak();
...
ui.on_request_name_accepted(move || { let ui = ui_1.unwrap(); let model = ui.get_model_property(); println!("{model:?}"); });
ui.on_request_start_accepted(move || { let ui = ui_2.unwrap(); let model = ui.get_model_property(); println!("{model:?}"); });
ui.on_request_end_accepted(move || { let ui = ui_3.unwrap().let model = ui.get_model_property(); println!("{model:?}"); });
...

appwindow.slint:

struct Model {
    name: string,
    start: string,
    end: string,
}

export component AppWindow inherits Window {
    callback request_name_accepted();
    callback request_start_accepted();
    callback request_end_accepted();
    in-out property<Model> model_property;
...

    LineEdit {
        placeholder-text: "Unnamed";
        text: root.model_property.name;
        accepted =>  { root.request-name-accepted(); }
    }
...

The callback in my rust code is being called, but all three fields of model are always "".

[ogoffart]

        text: root.model_property.name;

This is a one way binding. The text is assigned to the model, but not the other way arround. You need to update it in the accepted, for example

accepted =>  { 
   model_property.name = self.text;
   root.request-name-accepted();
 }

[bjorn]

1. It seems that I need to create a weak reference for EACH callback, so multiple variables instead of one single one.

I see this mostly as a shortcoming of Rust, since it appears lambdas can only use references (the default) or move values (when writing move ||, whereas C++ provides [=] { to create a lambda based on copies. To avoid the annoying creation of variables like ui_1, ui_2, etc. I have gotten into the habit of using this nice Rust feature (not sure what to call it):

ui.on_request_name_accepted({ let ui = ui.as_weak(); move || { let model = ui.unwrap().get_model_property(); println!("{model:?}"); }});
ui.on_request_start_accepted({ let ui = ui.as_weak(); move || { let model = ui.unwrap().get_model_property(); println!("{model:?}"); }});
ui.on_request_end_accepted({ let ui = ui.as_weak(); move || { let model = ui.unwrap().get_model_property(); println!("{model:?}"); }});

It narrows the scope of the weak ui variable, which I think is more readable. Almost like the C++ version, which would be [ui = slint::ComponentWeakHandle(ui)] { ... } (I think a convenience function would be nice here as well).

It might have been nice if the UI callbacks automatically received a reference to the UI as a parameter, but maybe there was a good reason to omit this.

[bjorn]

Maybe there could be an option set in the CompilerConfiguration through build.rs to change the generated code for the callbacks to include such a parameter? Then people can set this option and adjust their code in their own pace, and in Slint 2 the default could be flipped if it turns out to be simply more convenient.

[Tsuiban]

While a little cumbersome (but not your fault for the subersome-ness), that's a great idea, Bjorn. Thank you!

[tronical]

CompilerConfiguration is a good idea. Perhaps it could also be a kind of @codegen-pragma(rust:callbacks-with-component-handle) (or something shorter). But a project wide setting is probably most convenient.

[ogoffart]

btw, some implementation work was done before in #2035
IIRC we didn't include that because it did not simplify most of our example. But perhaps it does simplify the actual complex apps

[bjorn]

Hmm, it is true that it actually would not help my app much, and I also have my doubts about it being generally useful. This is because the callback could only take a reference to the UI component, which is rarely enough in a complex app.

Usually one needs access to other application state, so this cloning dance will still be required, and since you can put a reference to the UI in your application state, at least my code could not be simplified at all this way. It actually looks like:

struct App {
    // ...
    ui_weak: slint::Weak<AppWindow>,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut app = App::new();

    // ...

    let app = Arc::new(Mutex::new(app));
    let facade = ui.global::<Facade>();

    facade.on_ui_index_for_transaction({
        let app = app.clone();

        move |tx_index| {
            let app = app.lock();
            // ...
        }
    });

    // ...

    ui.run()?;
    Ok(())
}

(and I need Arc instead of Rc due to triggering some async tokio code in callbacks, even if I don't need this to be multi-threaded...)