Struct broot::app::Status

pub struct Status {
    pub message: String,
    pub error: bool,
}

the status contains information written on the grey line near the bottom of the screen

Fields

message: String

error: bool

Implementations

impl Status

pub fn new<S: Into<String>>(message: S, error: bool) -> Status

Examples found in repository

src/app/panel_state.rs (lines 939-942)

    fn get_status(
        &self,
        app_state: &AppState,
        cc: &CmdContext,
        has_previous_state: bool,
    ) -> Status {
        match &cc.cmd {
            Command::PatternEdit { .. } => self.no_verb_status(has_previous_state, cc.app.con),
            Command::VerbEdit(invocation) => {
                if invocation.name.is_empty() {
                    Status::new(
                        "Type a verb then *enter* to execute it (*?* for the list of verbs)",
                        false,
                    )
                } else {
                    let sel_info = self.sel_info(app_state);
                    match cc.app.con.verb_store.search_sel_info(
                        &invocation.name,
                        sel_info,
                    ) {
                        PrefixSearchResult::NoMatch => {
                            Status::new("No matching verb (*?* for the list of verbs)", true)
                        }
                        PrefixSearchResult::Match(_, verb) => {
                            self.get_verb_status(verb, invocation, sel_info, cc, app_state)
                        }
                        PrefixSearchResult::Matches(completions) => Status::new(
                            format!(
                                "Possible verbs: {}",
                                completions
                                    .iter()
                                    .map(|c| format!("*{}*", c))
                                    .collect::<Vec<String>>()
                                    .join(", "),
                            ),
                            false,
                        ),
                    }
                }
            }
            _ => self.no_verb_status(has_previous_state, cc.app.con),
        }
    }

    fn get_verb_status(
        &self,
        verb: &Verb,
        invocation: &VerbInvocation,
        sel_info: SelInfo<'_>,
        _cc: &CmdContext,
        app_state: &AppState,
    ) -> Status {
        if sel_info.count_paths() > 1 {
            if let VerbExecution::External(external) = &verb.execution {
                if external.exec_mode != ExternalExecutionMode::StayInBroot {
                    return Status::new(
                        "only verbs returning to broot on end can be executed on a multi-selection".to_owned(),
                        true,
                    );
                }
            }
            // right now there's no check for sequences but they're inherently dangereous
        }
        if let Some(err) = verb.check_args(sel_info, invocation, &app_state.other_panel_path) {
            Status::new(err, true)
        } else {
            Status::new(
                verb.get_status_markdown(
                    sel_info,
                    app_state,
                    invocation,
                ),
                false,
            )
        }
    }

pub fn from_message<S: Into<String>>(message: S) -> Status

Examples found in repository

src/app/panel.rs (line 61)

    pub fn set_message<S: Into<String>>(&mut self, md: S) {
        self.status = Status::from_message(md.into());
    }

src/app/panel_state.rs (lines 924-926)

    fn no_verb_status(
        &self,
        _has_previous_state: bool,
        _con: &AppContext,
    ) -> Status {
        Status::from_message(
            "Hit *esc* to get back, or a space to start a verb"
        )
    }

src/app/standard_status.rs (line 118)

    fn to_status(&self) -> Status {
        let mut md = String::new();
        for (i, p) in self.md_parts.iter().enumerate() {
            md.push_str(if i == 0 {
                "Hit "
            } else if i == self.md_parts.len() - 1 {
                ", or "
            } else {
                ", "
            });
            md.push_str(p);
        }
        Status::from_message(md)
    }

pub fn from_error<S: Into<String>>(message: S) -> Status

Examples found in repository

src/app/panel.rs (line 58)

    pub fn set_error(&mut self, text: String) {
        self.status = Status::from_error(text);
    }

src/browser/browser_state.rs (line 628)

    fn no_verb_status(
        &self,
        has_previous_state: bool,
        con: &AppContext,
    ) -> Status {
        let tree = self.displayed_tree();
        if tree.is_empty() {
            if tree.build_report.hidden_count > 0 {
                let mut parts = Vec::new();
                if let Some(md) = con.standard_status.all_files_hidden.clone() {
                    parts.push(md);
                }
                if let Some(md) = con.standard_status.all_files_git_ignored.clone() {
                    parts.push(md);
                }
                if !parts.is_empty() {
                    return Status::from_error(parts.join(". "));
                }
            }
        }
        let mut ssb = con.standard_status.builder(
            PanelStateType::Tree,
            tree.selected_line().as_selection(),
        );
        ssb.has_previous_state = has_previous_state;
        ssb.is_filtered = self.filtered_tree.is_some();
        ssb.has_removed_pattern = false;
        ssb.on_tree_root = tree.selection == 0;
        ssb.status()
    }

Trait Implementations

impl Clone for Status

fn clone(&self) -> Status

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Status

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.