Struct Handoff 

pub struct Handoff<Msg> { /* private fields */ }

Hands the terminal to another program: leaves raw mode and the alternate screen, runs it attached to the real terminal, then takes the screen back and draws everything again.

The program runs on the drawing thread and the application waits for it, which is what the user expects: they are talking to another program. Background tasks keep running, but nothing is drawn until the program ends.

On Unix, when the application is the foreground of its controlling terminal, the program runs in a process group of its own that is made the terminal’s foreground until it ends, as a shell runs a job. The signals of the keys — Ctrl-C at a sudo prompt, Ctrl-\ — and resizes then reach the program and its children only: the application is never ended by them, and its own signal dispositions are never changed. Ctrl-Z does not suspend: a program that stops is continued at once, since the application offers no way back to it. A process group is not a session, so the program keeps the controlling terminal and the session a warm sudo ticket is kept for.

use qframe::prelude::*;
use qframe::runtime::{Handoff, HandoffOutcome};

enum Msg {
    Authorize,
    Authorized(HandoffOutcome),
}

fn update(msg: Msg) -> Command<Msg> {
    match msg {
        // `sudo -v` asks for the password itself, on the terminal it owns for those seconds.
        Msg::Authorize => Command::handoff(
            Handoff::new("sudo", Msg::Authorized).arg("-v").notice("Authorizing the installation…"),
        ),
        Msg::Authorized(_) => Command::none(),
    }
}

Implementations

impl<Msg: Send + 'static> Handoff<Msg>

pub fn new( program: impl Into<OsString>, on_finish: impl FnOnce(HandoffOutcome) -> Msg + Send + 'static, ) -> Self

Runs program, delivering on_finish(outcome) once the application has the screen back.

pub fn arg(self, arg: impl Into<OsString>) -> Self

Adds one argument.

pub fn args(self, args: impl IntoIterator<Item = impl Into<OsString>>) -> Self

Adds several arguments, in order.

pub fn dir(self, dir: impl Into<PathBuf>) -> Self

Runs the program in dir instead of the application’s working directory.

pub fn env(self, key: impl Into<OsString>, value: impl Into<OsString>) -> Self

Sets an environment variable for the program. The rest of the environment is inherited.

pub fn notice(self, text: impl Into<String>) -> Self

A line printed on the cleared screen before the program starts, so the user knows why the application stepped aside.

pub fn pause(self, pause: bool) -> Self

Waits for a key press after the program ends, so its last output can be read. Off by default: a program that only takes a moment, such as sudo -v, has nothing to read.