What does the logic look like to capture input on Entry with GTK/Rust?

I am a React developer that is learning GTK version 3 with Rust. I am now working with Entry which is the equivalent to HTML input elements.

In React we have a value prop on an input element and you can extract in the browser via event.target.value.

How does that work when working with GTK/Rust Entry?

Again, in React I can do something like this:

const handleChange = (event) => {
    console.log(event.target.value);
  };

  return (
    <div>
      <form onSubmit={handleFormSubmit}>
        <input value={term} onChange={handleChange} />
      </form>
    </div>
  );
}

And console log the input provided. Now in the world of GTK I have done something like this:

fn build(&mut self) -> &mut Self {
  .entry("input_element")
    .with_entry(|input_element| {
      input_element.set_max_length(MAX_DESCRIPTION_LEN);
    })
  .end("input_element")
}

Is there a way to console log or read a value typed into the entry to verify it's receiving user input?

I know there is also event handling in GTK Rust with something like a button like so:

fn handle_change(&mut self, button: &Button) {
  let name = button.widget_name();
  if name.eq("button_name_text") {
    *self.button_name_text.borrow_mut() = button.clone();
  }
}

If there is also event handling to capture the input entered, what would that logic look like?

You can use EditableSignals::connect_changed.

Entry implements the EditableSignals trait, so it has the connect_changed method.

To get the text, you use the text method which Entry has via the extension trait EntryExt.

You can print using the println!() macro.

For example:

input_element.connect_changed(|target| {
    println!("You entered: {:?}", target.text());
    // `input_element` and `target` refer to the same `Entry`
});

Working standalone example:

use gtk::prelude::*;

fn main() {
    let application =
        gtk::Application::new(Some("stackoverflow.questions_75710906"), Default::default());

    application.connect_activate(|application| {
        let window = gtk::ApplicationWindow::new(application);

        let input_element = gtk::Entry::new();

        // ...
        input_element.connect_changed(|target| {
            println!("You entered: {:?}", target.text());
            // `input_element` and `target` refer to the same `Entry`
        });
        // ...

        window.add(&input_element);

        window.show_all();
    });

    application.run();
}