Struct App 

pub struct App { /* private fields */ }

Implementations

impl App

pub fn create( repo: Rc<Repository>, size: (u16, u16), args: &Args, config: Arc<Config>, enable_async_cmds: bool, piped: Option<Paged>, ) -> Res<Self>

pub fn run(&mut self, term: &mut Term, max_tick_delay: Duration) -> Res<()>

pub fn update(&mut self, term: &mut Term, event: Option<Event>) -> Res<()>

pub fn update_screens(&mut self) -> Res<()>

pub fn rerender_screens(&mut self) -> Res<()>

Rebuild every screen, leaving each cursor where it was in the diff rather than on the line number it happened to occupy. For a re-render of the same content (a renderer feature turned on or off), the rows move but the place in the patch does not.

pub fn handle_event(&mut self, term: &mut Term, event: Event) -> Res<()>

pub fn redraw_now(&mut self, term: &mut Term) -> Res<()>

pub fn print_if_one_screen(&mut self, term: &mut Term) -> Res<bool>

Prints the screen, and says so, if it fits on the terminal with a row to spare for the shell’s prompt: less’s --quit-if-one-screen. Waits for the rest of a screen still being drawn while what there is fits.

pub fn stage_redraw(&mut self)

pub fn close_menu(&mut self)

pub fn inhibit_close_menu(&mut self)

pub fn display_info<S: Into<Cow<'static, str>>>(&mut self, message: S)

Displays an Info message to the CmdLog.

pub fn display_error<S: Into<Cow<'static, str>>>(&mut self, message: S)

Displays an Error message to the CmdLog.

pub fn run_cmd( &mut self, term: &mut Term, input: &[u8], cmd: Command, ) -> Res<()>

Runs a Command and handles its output. Will block awaiting its completion.

pub fn run_cmd_async( &mut self, term: &mut Term, input: &[u8], cmd: Command, ) -> Res<()>

Runs a Command and handles its output asynchronously (if async commands are enabled). Will return Ok(()) if one is already running.

pub fn run_cmd_interactive(&mut self, term: &mut Term, cmd: Command) -> Res<()>

pub fn hide_menu(&mut self)

pub fn confirm(&mut self, term: &mut Term, prompt: &'static str) -> Res<()>

pub fn pick( &mut self, term: &mut Term, picker_state: PickerState, ) -> Res<Option<PickerData>>

Show a picker and wait for user to select an item or cancel.

Returns:

• Ok(Some(data)) - User selected an item
• Ok(None) - User cancelled (Esc or Ctrl-C)
• Err(e) - An error occurred

Example

let items = vec![
    PickerItem::new("main", PickerData::Item("main".to_string())),
    PickerItem::new("develop", PickerData::Item("develop".to_string())),
];
let picker = PickerState::new("Select branch", items, false);

match app.pick(term, picker)? {
    Some(PickerData::Item(name)) => {
        // User selected a branch
        println!("Selected: {}", name);
    }
    Some(PickerData::CustomInput(_)) => {
        // Should not happen when allow_custom_input is false
    }
    None => {
        // User cancelled
        println!("Cancelled");
    }
}

pub fn pick_commit(&mut self, term: &mut Term) -> Res<Option<String>>

Choose a commit by moving around a log view: the screen is pushed with its own keymap, and the loop runs until select_commit names one or the screen is closed.