Way to not issue a SIGTERM signal on Ctrl+c

[madprops]

Way to not issue a SIGTERM signal on Ctrl+c

[felipesere]

Sort of tangential to this, if I CTRL-C out of a selection, then my cursor is not restored.
Is that something I'd have to handle myself with some of the approaches named above?

[pksunkara]

Why was this closed?

[mainrs]

This could be done through a custom (global?) callback function that users of the library could set before instantiating any dialog components.

[filipelbc]

Same problem. Would like the program not to exit when ctrl-c is hit during input.

[filipelbc]

So, after investigating a little, this is not really an issue with the library. It actually catches the ^C and returns an "Interrupted" error. However, before this can happen, the default SIGINT handler exits the program.

In order to work around this, one has to "disable" the signal handler.

I could not find a "good" way to do this. Below's my awkward solution. Notice the need to first setup the SIGINT handler. ctrlc does not provide a way to change the handler after setting it, and signal_hook does not allow setting the signal handler again if you reset to a default (i.e. if you set an empty handler to avoid exiting the program, then reset to the "default" one later, then you cannot set it again if, e.g., you need a new input prompt).

use anyhow::{Context, Result};
use dialoguer::Input;
use signal_hook::{register, unregister, SigId, SIGINT};
use std::io::ErrorKind;

pub fn prompt(p: &str) -> Result<String> {
    with_sigint_disabled(|| do_prompt(p))
}

static mut SIGINT_HANDLER: Option<SigId> = None;

fn with_sigint_disabled<F, R>(f: F) -> Result<R>
where
    F: Fn() -> Result<R>,
{
    disable_sigint();
    let r = f();
    enable_sigint();
    r
}

pub fn enable_sigint() {
    unsafe {
        if SIGINT_HANDLER.is_none() {
            let signal = register(SIGINT, move || std::process::exit(128 + SIGINT)).unwrap();
            SIGINT_HANDLER = Some(signal);
        }
    }
}

fn disable_sigint() {
    unsafe {
        if let Some(s) = SIGINT_HANDLER {
            unregister(s);
            SIGINT_HANDLER = None;
        }
    }
}

fn do_prompt(p: &str) -> Result<String> {
    Input::new()
        .with_prompt(p)
        .allow_empty(true)
        .validate_with(|x: &String| {
            if x.trim().is_empty() {
                Err(format!("{} cannot be empty", p))
            } else {
                Ok(())
            }
        })
        .interact_text()
        .map(|x| x.trim().to_string())
        .map_err(|e| {
            if e.kind() == ErrorKind::Interrupted {
                println!("");
            }
            e
        })
        .with_context(|| format!("{} could not be read", p))
}

[pksunkara]

Can you try with https://lib.rs/crates/ctrlc?

[filipelbc]

I tried that one initially. The issue is that this one only lets you set the handler, but not disable it temporarily.

I just dawned on me that instead of disabling the handler, one could use a global flag, which is checked by the handler in order to decide what to do (e.g quit or nothing...).

Anyhow, not an issue with the library I guess. Just unexpected, given that in other languages this works out of the box.

std::string foo;
std::cin >> foo;

[mtorromeo]

@felipesere I just had this issue and this is how I restored the terminal:

let term = dialogue::console::Term::stderr();
term.show_cursor()?;

[pksunkara]

Showing the cursor should hopefully be fixed by #149 issue.

[pksunkara]

Closing this issue since it is not about this library.