Pre-fill EditText box with variable, and update TextView upon changes?

[tearfulnumpty]

I want a form with a few EditTexts (user String inputs) with prefilled data based on some variables (we'll call these A), and a final EditText box which dynamically updates whenever the underlying data for the other EditTexts update (should still be editable by the user as normal) (we'll call these B). I've built a partial implementation of this on top of the list_view example (https://github.com/gyscos/cursive/blob/main/cursive/examples/list_view.rs) but I'm not sure how to pre-fill the data, nor how to update the final EditText whenever the others change. Do I need a callback or something to do this?

I've got a function which can handle the logic for changing B whenever the A's update (taking either normal strings or a struct of Strings, and returns a single String), I just need a way to run it when appropriate and somehow use the resulting value and apply it to B.

Also, am I correct that I want to use something like siv.call_on_name("test", |view: &mut EditView| view.get_content()).unwrap().to_string(); to get the data out? It just seems quite complicated for what I'm sure is an extremely common use case.

---

So I guess in summary:

1. How can I pre-fill EditTexts with data from String variables? Nevermind, I found .content() now! I had tried set_content() before but that must be different.
2. How can I update the value inside of an EditText based on updates of other EditTexts/Variables? Ie. How can I edit B when any A's change? Am I looking for .on_edit() to call my function to change the value? But then how would I still update the other variable?
3. Is call_on_name the correct way to get my data back when I'm ready to pass it from cursive back to my existing control flow?

Thanks!

[tearfulnumpty]

I've tried the following to get my point/question 2 to work:

let mut mystruct = Arc::new(RwLock::new(MyStruct {
        var1: "foo".to_string(),
        var2: "bar".to_string(),
    }));


    let mystruct1 = Arc::clone(&mystruct);
    let mystruct2 = Arc::clone(&mystruct);
    let var1 = mystruct.var1;
    let var2 = mystruct.var2;

    .child("foo", EditView::new().content(var1)
                        .on_edit_mut(  move |s, text, _cursor| {
                            let mut somevar = mystruct1.write().unwrap();
                            somevar.var1 = text.to_string();
                            s.call_on_name("third_child", | view: &mut EditView | {
                                view.set_content(formatting_func(&somevar));
                             }
                            ).unwrap();})
                        .with_name("foo")
                        .min_width(20))
.child("bar", EditView::new().content(var2)
                        .on_edit_mut( move |s, text, _cursor| {
                            let mut somevar = mystruct2.write().unwrap();
                            somevar.var2 = text.to_string();
                            s.call_on_name("third_child", move | view: &mut EditView | {
                                view.set_content(formatting_func(&somevar)); }
                            // }
                            ).unwrap();})
                        .with_name("bar")
                        .min_width(20))

And while this doesn't throw any errors, my terminal simply hangs whenever I try to put any input at all into it and I have to forcibly kill it.

Any other solution I've tried either isn't thread safe (RefCell), or is moving each part of my struct that is assigned (var1, var2, etc) by text into the respective child (Just references, any combination of anything short of Arc<RwLock/Mutex>, etc) and thus ensuring that no child has full access to the full struct to pass into the formatting function due to the closure's move. Trying to drop somevar doesn't change anything either, so I'm not sure if it's a deadlock or something unrelated.

I'm not sure what else to try at this point. I'm assuming that there's a better approach somewhere, but I'm not finding it right now.

[gyscos]

Hi, and thanks for the questions!

Nevermind, I found .content() now! I had tried set_content() before but that must be different.

.content is just a convenient "chainable" method that calls .set_content then returns self, so you can keep chaining other functions.

2. How can I update the value inside of an EditText based on updates of other EditTexts/Variables? Ie. How can I edit B when any A's change? Am I looking for .on_edit() to call my function to change the value? But then how would I still update the other variable?

To run code when A changes, on_edit is indeed the way to go. on_edit_mut is the alternative in case you need a FnMut (which prevents calling the callback recursively). In many cases it's fine, as recursive callbacks are only useful in specific cases.

You're also correct in the way to update the content of B.

3. Is call_on_name the correct way to get my data back when I'm ready to pass it from cursive back to my existing control flow?

Yes, that's the generic way to alter or query part of the UI in callbacks. Some views might implement more convenient mechanisms through shared states (something like Rx), but EditView doesn't yet. We'd love to improve things here!

And while this doesn't throw any errors, my terminal simply hangs whenever I try to put any input at all into it and I have to forcibly kill it.

The problem with hanging might be that you're trying to lock that RwLock twice, probably from two on_edit callbacks. If you change a view content, it will trigger that view's on_edit callback. So if you try to lock the central RwLock in all callbacks, you need to make sure it's unlocked before changing a view content.

For example:

    .child("foo", EditView::new().content(var1)
                        .on_edit_mut(  move |s, text, _cursor| {
                            let new_content = {
                                let mut somevar = mystruct1.write().unwrap();
                                somevar.var1 = text.to_string();
                                formatting_func(&somevar)
                            };
                            s.call_on_name("third_child", | view: &mut EditView | {
                                view.set_content(new_content);
                             }
                            ).unwrap();})
                        .with_name("foo")
                        .min_width(20))

This will only lock while it prepares the new content, so that by the time you call set_content on another view, the struct is unlocked.

Note that to carry some data around, you may also make use of Cursive's user data:

// Start by setting the user data to our shared struct.
s.set_user_data(MyStruct { var1, var2 });

 layout.child("foo", EditView::new().content(var1)
                        .on_edit_mut(|s, text, _cursor| {
                            let new_content = {
                                // Here, no need to lock anything, just access the data.
                                let somevar: &mut MyStruct = s.user_data().unwrap();
                                somevar.var1 = text.to_string();
                                formatting_func(&somevar)
                            };
                            s.call_on_name("third_child", | view: &mut EditView | {
                                view.set_content(new_content);
                             }
                            ).unwrap();})
                        .with_name("foo")
                        .min_width(20))

It's of course not quite as generic a solution as manually sharing and locking, but it can simplify some simple situations like this.

[tearfulnumpty]

Thanks! That helps a lot.

I may try the userdata solution as well.

I made a simple mistake yesterday it seems, as I never dropped my lock for pulling var1, var2, etc out of the RwLock for the initial .content() call, duh (before the .child declarations)! It's working now, thanks.

---

Would your userdata solution be a bit more performant than an Arc<RwLock<Struct_of_several_strings>>? My use case for this means I'll be very very frequently destroying and re-calling the entire TUI, as I'll be looping through a lot of data. I understand that in reality this won't really matter, but I'm curious and trying to learn a bit more about the setup.

[gyscos]

Performance-wise, they would be very close. Both need to allocate the struct on the heap. The user data doesn't use atomics so might be ever so slightly faster to create. But I don't think the difference would be measurable. It'll also be dwarved by re-creating the entire UI. And if you have a lot of data, that sounds like a lot of allocation that may also vastly outweigh this.

The main advantage is the lack of any lock, which prevents by construction any deadlock. While, as you noticed, a lock could cause a deadlock if something goes wrong or is used incorrectly.

Instead, it forces you to handle the borrowing dance between the user data and call_on_name, both requiring exclusive access to &mut Cursive. But at least it's a compile-time concern, and not a runtime panic or deadlock.

[tearfulnumpty]

Thanks, that was my impression from reading your source as well. It's at least cleaner to read using user_data if nothing else. I had looked for, "states" in cursive but hadn't found them.

---

I may try to refactor my code a bit so that i don't have to continuously tear down my UI, but do you know a good way I could handle this?

Without knowing any cursive specific tricks I could try, my intuition is to use a multithreaded solution, with one thread providing the cursive TUI, and another handling an mpsc channel to advance data whenever cursive returns - though I don't know how to keep cursive's TUI open when reloading the data. Is there an example of this somewhere that I haven't found?

I guess I could just change the "Ok" or "Enter" functionality to pull off of the mpsc instead of closing the TUI, and just re-load my user_data at each call? Is it really that simple?