Modifying one View based on events from another

[vitorqb]

Hello there 👋

I've been trying to do something that should be simple but can't get my head around it. It's my first time using cursive.

Let's assume I have this setup:

SOURCE CODE

fn main() {

    let mut siv = cursive::default();

    let edit_view_1 = Panel::new(PaddedView::lrtb(1, 1, 1, 1, EditView::new().with_name("edit_view_1").fixed_width(20))).title("edit_view_1");
    let edit_view_2 = Panel::new(PaddedView::lrtb(1, 1, 1, 1, EditView::new().with_name("edit_view_2").fixed_width(20))).title("edit_view_2");
    let inputs_layout = LinearLayout::horizontal().child(edit_view_1).child(edit_view_2).with_name("inputs_layout");

    let text_view = Panel::new(PaddedView::lrtb(1, 1, 1, 1, TextView::new("<text_view>").with_name("text_view"))).title("text_view");

    let full_layout = cursive::views::LinearLayout::vertical()
        .child(inputs_layout)
        .child(text_view)
        .with_name("full_layout");
    siv.add_layer(full_layout);
    siv.run();
}

What I want to achieve is: I want to alter the text on text_view based on 2 kind of events: (a) when the user changes focus from one edit_view to another and (b) when the user enters inputs on the selected edit_view.

Those are examples of what I want to achieve:

My approach was to define my own FormView structure and try to play with ViewWrapper. Something like this

struct FormView {
    view: NamedView<LinearLayout>,
}

impl ViewWrapper for FormView {
    cursive::wrap_impl!(self.view: NamedView<LinearLayout>);

    fn wrap_on_event(&mut self, ch: Event) -> EventResult {
        let output = self.with_view_mut(|view| {
            view.on_event(ch)
        });
        self.view.with_view_mut(|view| {
            let focused_index = view.get_focus_index();
            if let Some(focused_view) = view.get_child(focused_index) {
                if let Some(x) = focused_view.downcast_ref::<NamedView<EditView>>() {
                    let name = x.name();
                    let value = x.with_view(|x| x.get_content()).unwrap();
                    let mut inputs_layout = self.view.find_name::<TextView>("inputs_layout").unwrap();
                    inputs_layout.set_content(format!("On {}: {}", name, value));
                }
            }
        });
        output.unwrap()
    }
}

This of course does not work, since self.view is "borrowed" multiple times

ERROR

error[E0501]: cannot borrow `self.view` as mutable because previous closure requires unique access
  --> src/main.rs:18:9
   |
18 |           self.view.with_view_mut(|view| {
   |           ^         ------------- ------ closure construction occurs here
   |           |         |
   |  _________|         first borrow later used by call
   | |
19 | |             let focused_index = view.get_focus_index();
20 | |             if let Some(focused_view) = view.get_child(focused_index) {
21 | |                 if let Some(x) = focused_view.downcast_ref::<NamedView<EditView>>() {
...  |
24 | |                     let mut inputs_layout = self.view.find_name::<TextView>("inputs_layout").unwrap();
   | |                                             --------- first borrow occurs due to use of `self.view` in closure
...  |
28 | |         });
   | |__________^ second borrow occurs here

error[E0500]: closure requires unique access to `self.view` but it is already borrowed
  --> src/main.rs:18:33
   |
18 |         self.view.with_view_mut(|view| {
   |         --------- ------------- ^^^^^^ closure construction occurs here
   |         |         |
   |         |         first borrow later used by call
   |         borrow occurs here
...
24 |                     let mut inputs_layout = self.view.find_name::<TextView>("inputs_layout").unwrap();
   |                                             --------- second borrow occurs due to use of `self.view` in closure

Could anyone point me to a direction I could take to make this work?

Thanks :)

[gyscos]

Hi, and thanks for the question!

First, you may be interested in the FocusTracker wrapper, which may help set callbacks for focus events.

Second, the double-borrow happens because you call find_name on self.view (the NamedView) while you're borrowing the layout. But you could directly call find_name on the layout instead. For that you do need the view to be un-borrowed.

You borrow it to prepare a string. Since the string itself doesn't borrow the view, you could first build the string while borrowing the view, then only keep the string, and use it to set the content:

fn wrap_on_event(&mut self, ch: Event) -> EventResult {
    let output = self.with_view_mut(|view| view.on_event(ch));
    self.view.with_view_mut(|view| {
        let focused_index = view.get_focus_index();

        // First build the content string
        let content = view
            .get_child(focused_index)
            .and_then(|view| view.downcast_ref::<NamedView<EditView>>())
            .map(|x| {
                let name = x.name();
                let value = x.with_view(|x| x.get_content()).unwrap();
                format!("On {name}: {value}")
            });
        // Now `view` is no longer borrowed, so we can use it again to find the child to edit.
        if let Some(content) = content {
            view.call_on_name("inputs_layout", |v: &mut TextView| {
                v.set_content(content);
            })
            .unwrap();
        }
    });
    output.unwrap()
}

[vitorqb]

Thank you 🤗