at what level are effects re-run

[JimitSoni18]

i want to make a reactive history stack for a file browser i intend to make.
please look at the following code:

// std
use std::{cell::RefCell, path::PathBuf, rc::Rc};

// deps
use floem::{
    reactive::{create_signal, ReadSignal, SignalGet, SignalUpdate, WriteSignal},
    views::{button, text},
    IntoView, View,
};

fn app() -> impl IntoView {
    let router = Rc::new(RefCell::new(Router::new()));
    let mut view: Vec<Box<dyn View>> = vec![];
    let location = router.borrow().location().get();
    let components = location.components();
    for (index, ref c) in components.enumerate() {
        let router = router.clone();
        let path_until: PathBuf = location
            .ancestors()
            .nth(location.components().count() - index - 1)
            .unwrap()
            .into();

        let path_until_clone = Rc::new(path_until);

        view.push(Box::new(
            button(c.as_os_str().to_str().unwrap_or("err").to_string())
                .action(move || router.borrow_mut().push((*path_until_clone).clone())),
        ));
        view.push(Box::new(text("/")));
    }

    view
}

struct Router {
    location: ReadSignal<PathBuf>,
    set_location: WriteSignal<PathBuf>,
    history: im::Vector<PathBuf>,
}

#[allow(unused)]
impl Router {
    fn new() -> Self {
        let cwd: PathBuf = std::env::var("HOME").unwrap_or("/".into()).into();
        let (location, set_location) = create_signal(cwd.clone());
        Self {
            history: im::vector![cwd],
            location,
            set_location,
        }
    }

    fn push(&mut self, path: PathBuf) {
        self.history.push_back(path.clone());
        self.set_location.set(path);
    }

    fn pop(&mut self) -> Option<PathBuf> {
        if self.history.len() > 1 {
            self.set_location.set(self.history.last().unwrap().clone());
            self.history.pop_back()
        } else {
            None
        }
    }

    fn location(&self) -> ReadSignal<PathBuf> {
        self.location
    }
}

fn main() {
    floem::launch(app)
}

The router gives out a ReadSignal of the last item of the history stack using the location() method, and internally keeps and updates the signal when the user calls pop() or push() methods. So in theory, the view that uses this signal to display elements should re-render when the value of this signal changes.

So in the app() function, I have made a simple breadcrumb view of the current directory by using the location signal, to show buttons for components until the current directory. When the user clicks on any of the button, the signal should update, to show the breadcrumbs of the corresponding directory.

For example:
If you are in the directory /home/username/projects, the signal is the PathBuf /home/username/projects.
So, it should show four buttons, /, home, username and projects.
When you click on username button, the signal should update to /home/username, and the buttons should be re-rendered to show three buttons only: /, home and username.
But this does not happen.

So at what level does the effect re-run to update the UI? Does the signal have to be used inside the struct that implements View/IntoView?

[JimitSoni18]

I have checked by placing a println in the action, that the signal is indeed being updated on button press:

            button(c.as_os_str().to_str().unwrap_or("err").to_string())
                .action(move || {
                    println!("currentlocation: {:?}", router.borrow().location().get());
                    router.borrow_mut().push((*path_until_clone).clone())
                }),

[dzhou121]

You need dyn_stack for this.

Here is an example https://github.com/lapce/floem/blob/main/examples/stacks/src/dyn_stack.rs

[jrmoulton]

Some of the docs that I am working on adding such as
https://lapce.dev/floem/floem/index.html#views

and
https://lapce.dev/floem/floem/index.html#functions-as-a-primitive-of-reactivity

will help to clarify what is reactive and what is not.

[JimitSoni18]

@jrmoulton @dzhou121 thanks!!