Update signal from another thread

[MalpenZibo]

Maybe is not possible because this library is primary focus on web application but using gtk I need to change the signal value from another thread.

Here's an example using the gtk example present in the repository

use gtk::{prelude::*, Application, ApplicationWindow, Button};
use leptos::*;

const APP_ID: &str = "dev.leptos.Counter";

// Basic GTK app setup from https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html
fn main() {
    let _ = create_runtime();
    // Create a new application
    let app = Application::builder().application_id(APP_ID).build();

    // Connect to "activate" signal of `app`
    app.connect_activate(build_ui);

    // Run the application
    app.run();
}

fn build_ui(app: &Application) {
    let button = counter_button();

    // Create a window and set the title
    let window = ApplicationWindow::builder()
        .application(app)
        .title("Leptos-GTK")
        .child(&button)
        .build();

    // Present window
    window.present();
}

fn counter_button() -> Button {
    let (value, set_value) = create_signal(0);

    // Create a button with label and margins
    let button = Button::builder()
        .label("Count: ")
        .margin_top(12)
        .margin_bottom(12)
        .margin_start(12)
        .margin_end(12)
        .build();

    // here I need to update the value from another thread
    tokio::spawn(async move {
        loop {
            sleep(Duration::from_millis(10000));
            println!("update");
            set_counter.update(|counter| *counter += 1);
        }
    });

    create_effect({
        let button = button.clone();
        move |_| {
            button.set_label(&format!("Count: {}", value()));
        }
    });

    button
}

With this code, I get Attempted to update a signal after it was disposed.

There's a way to make this example work?

For reference in my real project, I need to listen to a hyprland event using the hyprland crate

    tokio::spawn({
        async move {
            let mut event_listener = EventListener::new();

            event_listener.add_active_window_change_handler(move |e| {
                set_counter.update(|counter| *counter += 1);
            });

            event_listener
                .start_listener_async()
                .await
                .expect("failed to start active window listener");
        }
    });

[gbj]

No, the reactive system itself is explicitly single-threaded. I'm surprised that it even compiled, but I guess it's because you are sending a WriteSignal which is really just an index type and so doesn't get inferred as !Send.

You can't update a signal from another thread. You could send a channel transmitter across threads and listen for it on this thread, and then update the signal. I don't know much more about this and have never tried it, unfortunately.

[MalpenZibo]

Ok, thanks.
I was able to find a "solution" anyway. Based on this repo https://github.com/rodrigorc/gidle_future I was able to create a spawn function that runs a future on the main thread of the GTK.

The final code looks like this and it seems working.

const APP_ID: &str = "dev.leptos.Counter";

// Basic GTK app setup from https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html
fn main() {
    let _ = create_runtime();
    // Create a new application
    let app = Application::builder().application_id(APP_ID).build();

    // Connect to "activate" signal of `app`
    app.connect_activate(build_ui);

    // Run the application
    app.run();
}

fn build_ui(app: &Application) {
    let button = counter_button();

    // Create a window and set the title
    let window = ApplicationWindow::builder()
        .application(app)
        .title("Leptos-GTK")
        .child(&button)
        .build();

    // Present window
    window.present();
}

fn counter_button() -> Button {
    let (value, set_value) = create_signal(0);

    // Create a button with label and margins
    let button = Button::builder()
        .label("Count: ")
        .margin_top(12)
        .margin_bottom(12)
        .margin_start(12)
        .margin_end(12)
        .build();

    //Here I need to update the value from another thread
    //The `spawn` function is the same present on this repo https://github.com/rodrigorc/gidle_future
    // I changed some minor stuff only
    spawn(async move {
        loop {
            time::sleep(Duration::from_millis(1000)).await;

            set_counter.update(|counter| *counter += 1);
        }
    });

    create_effect({
        let button = button.clone();
        move |_| {
            button.set_label(&format!("Count: {}", value()));
        }
    });

    button
}

[gbj]

@MalpenZibo Given this conversation, I just wanted to send a quick note to say that I've been actively working on a "universal rendering" approach for 0.6, and it includes both

1. multithreaded reactivity, and
2. a GTK integration

You can check out the GTK example here https://github.com/gbj/tachys/blob/main/examples/gtk/src/main.rs

This is all quite experimental still, but if it's something you're interested in I would love to have help building out the GTK example in the future. It's basically a matter of designing good interfaces for the GTK widgets; as you can see so far I've only done Box and Button so it's just a POC.

Interestingly, I did actually have to implement an interface for the reactive system in terms of the glib event loop rather than tokio, so I think your solution is exactly right. You can't use tokio and glib on the same, main thread — which makes perfect sense, really.

But yeah it's pretty sick to be able to write this and have it just work across (system!) threads:

fn ui() -> impl Render<TachyGtk> {
    let value = Signal::new(0);
    let rows = Signal::new(vec![1, 2, 3, 4, 5]);

    Effect::new(move |_| {
        println!("value = {}", value.get());
    });

    // just an example of multithreaded reactivity
    thread::spawn(move || loop {
        thread::sleep(Duration::from_millis(250));
        value.update(|n| *n += 1);
    });
    
    (
        button("-1", move |_| value.update(|n| *n -= 1)),
        move || value.get().to_string(),
        button("+1", move |_| value.update(|n| *n += 1)),
    )
}

[MalpenZibo]

Hi, very interesting!
Currently, I'm working on a shell for my hyprland setup. I tried to use Leptos but in the end, I had some freeze and memory leak issues (I'm not sure if there was a mistake in my code in the hack solution to make the Leptos reactive system work in a multithread context with glib).

For this reason, currently, I'm using another library futures-signals. If could be useful here there's the code before the switch to futures-signals. It's not very "refined" but inside the gtk4_wrapper, there's everything that I do to integrate leptos with gtk4.