SelectView can't be found by name with custom structs

[tlafebre]

Hello,

I'm struggling with a SelectView on a collection of custom structs for which I want to implement certain behaviour if a certain item is selected.
So, I'm trying to implement an "on_select" callback in which I want to find the id of the currently selected item.

However, when I do a "call_on_name" for that SelectView it keeps returning None as if there is no view available with that name.

In the simplified code example I have 2 similar sets of functions:

1. a SelectView with custom 'Person' structs which doens't work. Selecting a Person in the SelectView crashes on the unwrap, as if the view could not be found in the Cursive Object.
2. a SelectView with Strings which works (Currently commented out). selecting a String in the SelectView shows the id of that string in the TextView up top.

use cursive::view::Nameable;
use cursive::views::{Dialog, LinearLayout, NamedView, SelectView, TextView};
use cursive::{Cursive, CursiveExt};

#[derive(Debug, Clone, PartialEq)]
pub struct Person {
    pub name: String,
}

fn select_view() -> NamedView<SelectView<Person>> {
    let p1 = Person {
        name: "Bob".to_string(),
    };

    let p2 = Person {
        name: "Alice".to_string(),
    };

    let select = SelectView::<Person>::new()
        .on_select(|s: &mut Cursive, p: &Person| on_select_person(s, p))
        .item("First Person", p1)
        .item("Second Person", p2);

    select.with_name("select")
}

fn on_select_person(s: &mut Cursive, _p: &Person) {
    let curr = s
        .call_on_name("select", |view: &mut SelectView| view.selected_id())
        .unwrap();

    s.call_on_name("text", |v: &mut TextView| {
        v.set_content(format!("{:?}", curr))
    });
}

//fn select_view() -> NamedView<SelectView<String>> {
//    let mut select = SelectView::<String>::new()
//        .on_select(|s: &mut Cursive, p: &String| on_select_string(s, p))
//        .item("First Person", "Alice".to_string())
//        .item("Second Person", "Bob".to_string());
//
//    select.with_name("select")
//}
//
//fn on_select_string(s: &mut Cursive, p: &String) {
//    let curr = s
//        .call_on_name("select", |view: &mut SelectView| view.selected_id())
//        .unwrap();
//
//    s.call_on_name("text", |v: &mut TextView| {
//        v.set_content(format!("{:?}", curr))
//    });
//}

fn main() {
    let mut siv = Cursive::new();
    let text_view = TextView::empty().with_name("text");
    let select = select_view();

    let layout = LinearLayout::vertical()
        .child(Dialog::around(text_view))
        .child(Dialog::around(select));

    siv.add_layer(layout);
    siv.add_global_callback('q', |s| s.quit());
    siv.run();
}

What am I missing?

Thanks in advance!

[gyscos]

Hi, and thanks for the report!

You'll need to specify the generic type of the SelectView you are looking for. It defaults to String otherwise, which is not that you want here.

[tlafebre]

It works now. thanks a lot! :-)

[tlafebre]

Maybe this is a somewhat odd follow up question but: Is there some way I could have found out about this requirement by myself?
Is it described in the documentation and if so, what did I miss in reading it?

[gyscos]

Well, the information is there, but probably not easy to find.

• SelectView is generic - it's part of its type information. You did notice that, using it in a return type NamedView<SelectView<Person>>.
  You can see in the doc that it defaults to T = String (though it's very easy to miss).
• Cursive::call_on_name requires the exact type of the view you're looking for. That's one part where the doc is probably not clear enough about that. The related find_name has more to say about that:

Note that you must specify the exact type for the view you’re after; for example, using the wrong item type in a SelectView will not find anything: ...

Now I do agree that it should be communicated better:

• The warning on the find_name documentation should be copied, or mentioned from the call_on_name doc.
• SelectView could include in its own doc that it is generic and any use of call_on_name (or similar methods) should be careful to use the exact type here.
• SelectView could also drop the default T = String parameter - I think at this point it does more harm than good. Thinking about it, there's no real reason to have such a default parameter.

Note that there is one last thing you can try in situations like that: Cursive::debug_name returns the name of the type of a view under the given name. So in your case it might have returned "SelectView<Person>", potentially hinting at the importance of the generic parameter.

[tlafebre]

Cool, that helps me a lot! thanks