Struct broot::filesystems::FilesystemState

source ·

pub struct FilesystemState { /* private fields */ }

Expand description

an application state showing the currently mounted filesystems

Implementations§

source §

impl FilesystemState

source

pub fn new(
 path: Option<&Path>,
 tree_options: TreeOptions,
 con: &AppContext
) -> Result<FilesystemState, ProgramError>

create a state listing the filesystem, trying to select the one containing the path given in argument. Not finding any filesystem is considered an error and prevents the opening of this state.

Examples found in repository ?

src/app/panel_state.rs (lines 139-143)

    fn on_internal_generic(
        &mut self,
        _w: &mut W,
        internal_exec: &InternalExecution,
        input_invocation: Option<&VerbInvocation>,
        _trigger_type: TriggerType,
        app_state: &mut AppState,
        cc: &CmdContext,
    ) -> Result<CmdResult, ProgramError> {
        let con = &cc.app.con;
        let screen = cc.app.screen;
        let bang = input_invocation
            .map(|inv| inv.bang)
            .unwrap_or(internal_exec.bang);
        Ok(match internal_exec.internal {
            Internal::back => CmdResult::PopState,
            Internal::copy_line | Internal::copy_path => {
                #[cfg(not(feature = "clipboard"))]
                {
                    CmdResult::error("Clipboard feature not enabled at compilation")
                }
                #[cfg(feature = "clipboard")]
                {
                    if let Some(path) = self.selected_path() {
                        let path = path.to_string_lossy().to_string();
                        match terminal_clipboard::set_string(path) {
                            Ok(()) => CmdResult::Keep,
                            Err(_) => CmdResult::error("Clipboard error while copying path"),
                        }
                    } else {
                        CmdResult::error("Nothing to copy")
                    }
                }
            }
            Internal::close_panel_ok => CmdResult::ClosePanel {
                validate_purpose: true,
                panel_ref: PanelReference::Active,
            },
            Internal::close_panel_cancel => CmdResult::ClosePanel {
                validate_purpose: false,
                panel_ref: PanelReference::Active,
            },
            #[cfg(unix)]
            Internal::filesystems => {
                let fs_state = crate::filesystems::FilesystemState::new(
                    self.selected_path(),
                    self.tree_options(),
                    con,
                );
                match fs_state {
                    Ok(state) => {
                        let bang = input_invocation
                            .map(|inv| inv.bang)
                            .unwrap_or(internal_exec.bang);
                        if bang && cc.app.preview_panel.is_none() {
                            CmdResult::NewPanel {
                                state: Box::new(state),
                                purpose: PanelPurpose::None,
                                direction: HDir::Right,
                            }
                        } else {
                            CmdResult::new_state(Box::new(state))
                        }
                    }
                    Err(e) => CmdResult::DisplayError(format!("{}", e)),
                }
            }
            Internal::help => {
                let bang = input_invocation
                    .map(|inv| inv.bang)
                    .unwrap_or(internal_exec.bang);
                if bang && cc.app.preview_panel.is_none() {
                    CmdResult::NewPanel {
                        state: Box::new(HelpState::new(self.tree_options(), screen, con)),
                        purpose: PanelPurpose::None,
                        direction: HDir::Right,
                    }
                } else {
                    CmdResult::new_state(Box::new(
                            HelpState::new(self.tree_options(), screen, con)
                    ))
                }
            }
            Internal::mode_input => self.on_mode_verb(Mode::Input, con),
            Internal::mode_command => self.on_mode_verb(Mode::Command, con),
            Internal::open_leave => {
                if let Some(selection) = self.selection() {
                    selection.to_opener(con)?
                } else {
                    CmdResult::error("no selection to open")
                }
            }
            Internal::open_preview => self.open_preview(None, false, cc),
            Internal::preview_image => self.open_preview(Some(PreviewMode::Image), false, cc),
            Internal::preview_text => self.open_preview(Some(PreviewMode::Text), false, cc),
            Internal::preview_binary => self.open_preview(Some(PreviewMode::Hex), false, cc),
            Internal::toggle_preview => self.open_preview(None, true, cc),
            Internal::sort_by_count => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::Count {
                        o.sort = Sort::None;
                        o.show_counts = false;
                        "*not sorting anymore*"
                    } else {
                        o.sort = Sort::Count;
                        o.show_counts = true;
                        "*now sorting by file count*"
                    }
                },
                bang,
                con,
            ),
            Internal::sort_by_date => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::Date {
                        o.sort = Sort::None;
                        o.show_dates = false;
                        "*not sorting anymore*"
                    } else {
                        o.sort = Sort::Date;
                        o.show_dates = true;
                        "*now sorting by last modified date*"
                    }
                },
                bang,
                con,
            ),
            Internal::sort_by_size => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::Size {
                        o.sort = Sort::None;
                        o.show_sizes = false;
                        "*not sorting anymore*"
                    } else {
                        o.sort = Sort::Size;
                        o.show_sizes = true;
                        o.show_root_fs = true;
                        "*now sorting files and directories by total size*"
                    }
                },
                bang,
                con,
            ),
            Internal::sort_by_type => self.with_new_options(
                screen,
                &|o| {
                    match o.sort {
                        Sort::TypeDirsFirst => {
                           o.sort = Sort::TypeDirsLast;
                           "*sorting by type, directories last*"
                        }
                        Sort::TypeDirsLast => {
                            o.sort = Sort::None;
                            "*not sorting anymore*"
                        }
                        _ => {
                            o.sort = Sort::TypeDirsFirst;
                           "*sorting by type, directories first*"
                        }
                    }
                },
                bang,
                con,
            ),
            Internal::sort_by_type_dirs_first => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::TypeDirsFirst {
                        o.sort = Sort::None;
                        "*not sorting anymore*"
                    } else {
                        o.sort = Sort::TypeDirsFirst;
                        "*now sorting by type, directories first*"
                    }
                },
                bang,
                con,
            ),
            Internal::sort_by_type_dirs_last => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::TypeDirsLast {
                        o.sort = Sort::None;
                        "*not sorting anymore*"
                    } else {
                        o.sort = Sort::TypeDirsLast;
                        "*now sorting by type, directories last*"
                    }
                },
                bang,
                con,
            ),
            Internal::no_sort => self.with_new_options(
                screen,
                &|o| {
                    if o.sort == Sort::None {
                        "*still not searching*"
                    } else {
                        o.sort = Sort::None;
                        "*not sorting anymore*"
                    }
                },
                bang,
                con,
            ),
            Internal::toggle_counts => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_counts ^= true;
                        if o.show_counts {
                            "*displaying file counts*"
                        } else {
                            "*hiding file counts*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_dates => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_dates ^= true;
                        if o.show_dates {
                            "*displaying last modified dates*"
                        } else {
                            "*hiding last modified dates*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_device_id => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_device_id ^= true;
                        if o.show_device_id {
                            "*displaying device id*"
                        } else {
                            "*hiding device id*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_files => {
                self.with_new_options(
					screen,
					&|o| {
                        o.only_folders ^= true;
                        if o.only_folders {
                            "*displaying only directories*"
                        } else {
                            "*displaying both files and directories*"
                        }
                    },
					bang,
					con,
				)
            }
            Internal::toggle_hidden => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_hidden ^= true;
                        if o.show_hidden {
                            "h:**y** - *Hidden files displayed*"
                        } else {
                            "h:**n** - *Hidden files not displayed*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_root_fs => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_root_fs ^= true;
                        if o.show_root_fs {
                            "*displaying filesystem info for the tree's root directory*"
                        } else {
                            "*removing filesystem info*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_git_ignore => {
                self.with_new_options(
					screen,
					&|o| {
						o.respect_git_ignore ^= true;
                        if o.respect_git_ignore {
                            "gi:**y** - *applying gitignore rules*"
                        } else {
                            "gi:**n** - *not applying gitignore rules*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_git_file_info => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_git_file_info ^= true;
                        if o.show_git_file_info {
                            "*displaying git info next to files*"
                        } else {
                            "*removing git file info*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_git_status => {
                self.with_new_options(
                    screen, &|o| {
                        if o.filter_by_git_status {
                            o.filter_by_git_status = false;
                            "*not filtering according to git status anymore*"
                        } else {
                            o.filter_by_git_status = true;
                            o.show_hidden = true;
                            "*only displaying new or modified files*"
                        }
                    }, bang, con
                )
            }
            Internal::toggle_perm => {
                self.with_new_options(
					screen,
					&|o| {
						o.show_permissions ^= true;
                        if o.show_permissions {
                            "*displaying file permissions*"
                        } else {
                            "*removing file permissions*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::toggle_sizes => self.with_new_options(
                screen,
                &|o| {
                    if o.show_sizes {
                        o.show_sizes = false;
                        o.show_root_fs = false;
                        "*removing sizes of files and directories*"
                    } else {
                        o.show_sizes = true;
                        o.show_root_fs = true;
                        "*now diplaying sizes of files and directories*"
                    }
                },
                bang,
                con,
            ),
            Internal::toggle_trim_root => {
                self.with_new_options(
					screen,
					&|o| {
						o.trim_root ^= true;
                        if o.trim_root {
                            "*now trimming root from excess files*"
                        } else {
                            "*not trimming root files anymore*"
                        }
					},
					bang,
					con,
				)
            }
            Internal::close_preview => {
                if let Some(id) = cc.app.preview_panel {
                    CmdResult::ClosePanel {
                        validate_purpose: false,
                        panel_ref: PanelReference::Id(id),
                    }
                } else {
                    CmdResult::Keep
                }
            }
            Internal::panel_left | Internal::panel_left_no_open => {
                CmdResult::HandleInApp(Internal::panel_left_no_open)
            }
            Internal::panel_right | Internal::panel_right_no_open => {
                CmdResult::HandleInApp(Internal::panel_right_no_open)
            }
            Internal::toggle_second_tree => {
                CmdResult::HandleInApp(Internal::toggle_second_tree)
            }
            Internal::clear_stage => {
                app_state.stage.clear();
                if let Some(panel_id) = cc.app.stage_panel {
                    CmdResult::ClosePanel {
                        validate_purpose: false,
                        panel_ref: PanelReference::Id(panel_id),
                    }
                } else {
                    CmdResult::Keep
                }
            }
            Internal::stage => self.stage(app_state, cc, con),
            Internal::unstage => self.unstage(app_state, cc, con),
            Internal::toggle_stage => self.toggle_stage(app_state, cc, con),
            Internal::close_staging_area => {
                if let Some(id) = cc.app.stage_panel {
                    CmdResult::ClosePanel {
                        validate_purpose: false,
                        panel_ref: PanelReference::Id(id),
                    }
                } else {
                    CmdResult::Keep
                }
            }
            Internal::open_staging_area => {
                if cc.app.stage_panel.is_none() {
                    CmdResult::NewPanel {
                        state: Box::new(StageState::new(app_state, self.tree_options(), con)),
                        purpose: PanelPurpose::None,
                        direction: HDir::Right,
                    }
                } else {
                    CmdResult::Keep
                }
            }
            Internal::toggle_staging_area => {
                if let Some(id) = cc.app.stage_panel {
                    CmdResult::ClosePanel {
                        validate_purpose: false,
                        panel_ref: PanelReference::Id(id),
                    }
                } else {
                    CmdResult::NewPanel {
                        state: Box::new(StageState::new(app_state, self.tree_options(), con)),
                        purpose: PanelPurpose::None,
                        direction: HDir::Right,
                    }
                }
            }
            Internal::set_syntax_theme => CmdResult::HandleInApp(Internal::set_syntax_theme),
            Internal::print_path => print::print_paths(self.sel_info(app_state), con)?,
            Internal::print_relative_path => print::print_relative_paths(self.sel_info(app_state), con)?,
            Internal::refresh => CmdResult::RefreshState { clear_cache: true },
            Internal::quit => CmdResult::Quit,
            _ => CmdResult::Keep,
        })
    }

source

pub fn count(&self) -> usize

Examples found in repository ?

src/filesystems/filesystems_state.rs (line 110)

    pub fn try_scroll(
        &mut self,
        cmd: ScrollCommand,
    ) -> bool {
        let old_scroll = self.scroll;
        self.scroll = cmd.apply(self.scroll, self.count(), self.page_height);
        if self.selection_idx < self.scroll {
            self.selection_idx = self.scroll;
        } else if self.selection_idx >= self.scroll + self.page_height {
            self.selection_idx = self.scroll + self.page_height - 1;
        }
        self.scroll != old_scroll
    }

    /// change the selection
    fn move_line(
        &mut self,
        internal_exec: &InternalExecution,
        input_invocation: Option<&VerbInvocation>,
        dir: i32, // -1 for up, 1 for down
        cycle: bool,
    ) -> CmdResult {
        let count = get_arg(input_invocation, internal_exec, 1);
        let dir = dir * count as i32;
        if let Some(f) = self.filtered.as_mut() {
            f.selection_idx = move_sel(f.selection_idx, f.mounts.len(), dir, cycle);
        } else {
            self.selection_idx = move_sel(self.selection_idx, self.mounts.len().get(), dir, cycle);
        }
        if self.selection_idx < self.scroll {
            self.scroll = self.selection_idx;
        } else if self.selection_idx >= self.scroll + self.page_height {
            self.scroll = self.selection_idx + 1 - self.page_height;
        }
        CmdResult::Keep
    }

    fn no_opt_selected_path(&self) -> &Path {
        &self.mounts[self.selection_idx].info.mount_point
    }

    fn no_opt_selection(&self) -> Selection<'_> {
        Selection {
            path: self.no_opt_selected_path(),
            stype: SelectionType::Directory,
            is_exe: false,
            line: 0,
        }
    }
}

impl PanelState for FilesystemState {

    fn get_type(&self) -> PanelStateType {
        PanelStateType::Fs
    }

    fn set_mode(&mut self, mode: Mode) {
        self.mode = mode;
    }

    fn get_mode(&self) -> Mode {
        self.mode
    }

    fn selected_path(&self) -> Option<&Path> {
        Some(self.no_opt_selected_path())
    }

    fn tree_options(&self) -> TreeOptions {
        self.tree_options.clone()
    }

    fn with_new_options(
        &mut self,
        _screen: Screen,
        change_options: &dyn Fn(&mut TreeOptions) -> &'static str,
        _in_new_panel: bool, // TODO open tree if true
        _con: &AppContext,
    ) -> CmdResult {
        change_options(&mut self.tree_options);
        CmdResult::Keep
    }

    fn selection(&self) -> Option<Selection<'_>> {
        Some(self.no_opt_selection())
    }

    fn refresh(&mut self, _screen: Screen, _con: &AppContext) -> Command {
        Command::empty()
    }

    fn on_pattern(
        &mut self,
        pattern: InputPattern,
        _app_state: &AppState,
        _con: &AppContext,
    ) -> Result<CmdResult, ProgramError> {
        if pattern.is_none() {
            self.filtered = None;
        } else {
            let mut selection_idx = 0;
            let mut mounts = Vec::new();
            let pattern = pattern.pattern;
            for (idx, mount) in self.mounts.iter().enumerate() {
                if pattern.score_of_string(&mount.info.fs).is_none()
                    && mount.disk.as_ref().and_then(|d| pattern.score_of_string(d.disk_type())).is_none()
                    && pattern.score_of_string(&mount.info.fs_type).is_none()
                    && pattern.score_of_string(&mount.info.mount_point.to_string_lossy()).is_none()
                { continue; }
                if idx <= self.selection_idx {
                    selection_idx = mounts.len();
                }
                mounts.push(mount.clone());
            }
            self.filtered = Some(FilteredContent {
                pattern,
                mounts,
                selection_idx,
            });
        }
        Ok(CmdResult::Keep)
    }

    fn display(
        &mut self,
        w: &mut W,
        disc: &DisplayContext,
    ) -> Result<(), ProgramError> {
        let area = &disc.state_area;
        let con = &disc.con;
        self.page_height = area.height as usize - 2;
        let (mounts, selection_idx) = if let Some(filtered) = &self.filtered {
            (filtered.mounts.as_slice(), filtered.selection_idx)
        } else {
            (self.mounts.as_slice(), self.selection_idx)
        };
        let scrollbar = area.scrollbar(self.scroll, mounts.len());
        //- style preparation
        let styles = &disc.panel_skin.styles;
        let selection_bg = styles.selected_line.get_bg()
            .unwrap_or(Color::AnsiValue(240));
        let match_style = &styles.char_match;
        let mut selected_match_style = styles.char_match.clone();
        selected_match_style.set_bg(selection_bg);
        let border_style = &styles.help_table_border;
        let mut selected_border_style = styles.help_table_border.clone();
        selected_border_style.set_bg(selection_bg);
        //- width computations and selection of columns to display
        let width = area.width as usize;
        let w_fs = mounts.iter()
            .map(|m| m.info.fs.chars().count())
            .max().unwrap_or(0)
            .max("filesystem".len());
        let mut wc_fs = w_fs; // width of the column (may include selection mark)
        if con.show_selection_mark {
            wc_fs += 1;
        }
        let w_dsk = 5; // max width of a lfs-core disk type
        let w_type = mounts.iter()
            .map(|m| m.info.fs_type.chars().count())
            .max().unwrap_or(0)
            .max("type".len());
        let w_size = 4;
        let w_use = 4;
        let mut w_use_bar = 1; // min size, may grow if space available
        let w_use_share = 4;
        let mut wc_use = w_use; // sum of all the parts of the usage column
        let w_free = 4;
        let w_mount_point = mounts.iter()
            .map(|m| m.info.mount_point.to_string_lossy().chars().count())
            .max().unwrap_or(0)
            .max("mount point".len());
        let w_mandatory = wc_fs + 1 + w_size + 1 + w_free + 1 + w_mount_point;
        let mut e_dsk = false;
        let mut e_type = false;
        let mut e_use_bar = false;
        let mut e_use_share = false;
        let mut e_use = false;
        if w_mandatory + 1 < width {
            let mut rem = width - w_mandatory - 1;
            if rem > w_use {
                rem -= w_use + 1;
                e_use = true;
            }
            if e_use && rem > w_use_share {
                rem -= w_use_share; // no separation with use
                e_use_share = true;
                wc_use += w_use_share;
            }
            if rem > w_dsk {
                rem -= w_dsk + 1;
                e_dsk = true;
            }
            if e_use && rem > w_use_bar {
                rem -= w_use_bar + 1;
                e_use_bar = true;
                wc_use += w_use_bar + 1;
            }
            if rem > w_type {
                rem -= w_type + 1;
                e_type = true;
            }
            if e_use_bar && rem > 0 {
                let incr = rem.min(9);
                w_use_bar += incr;
                wc_use += incr;
            }
        }
        //- titles
        w.queue(cursor::MoveTo(area.left, area.top))?;
        let mut cw = CropWriter::new(w, width);
        cw.queue_g_string(&styles.default, format!("{:wc_fs$}", "filesystem"))?;
        cw.queue_char(border_style, '│')?;
        if e_dsk {
            cw.queue_g_string(&styles.default, "disk ".to_string())?;
            cw.queue_char(border_style, '│')?;
        }
        if e_type {
            cw.queue_g_string(&styles.default, format!("{:^w_type$}", "type"))?;
            cw.queue_char(border_style, '│')?;
        }
        if e_use {
            cw.queue_g_string(&styles.default, format!(
                "{:^width$}", if wc_use > 4 { "usage" } else { "use" }, width = wc_use
            ))?;
            cw.queue_char(border_style, '│')?;
        }
        cw.queue_g_string(&styles.default, "free".to_string())?;
        cw.queue_char(border_style, '│')?;
        cw.queue_g_string(&styles.default, "size".to_string())?;
        cw.queue_char(border_style, '│')?;
        cw.queue_g_string(&styles.default, "mount point".to_string())?;
        cw.fill(border_style, &SPACE_FILLING)?;
        //- horizontal line
        w.queue(cursor::MoveTo(area.left, 1 + area.top))?;
        let mut cw = CropWriter::new(w, width);
        cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = wc_fs + 1))?;
        if e_dsk {
            cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = w_dsk + 1))?;
        }
        if e_type {
            cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = w_type+1))?;
        }
        cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = w_size+1))?;
        if e_use {
            cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = wc_use+1))?;
        }
        cw.queue_g_string(border_style, format!("{:─>width$}", '┼', width = w_free+1))?;
        cw.fill(border_style, &BRANCH_FILLING)?;
        //- content
        let mut idx = self.scroll as usize;
        for y in 2..area.height {
            w.queue(cursor::MoveTo(area.left, y + area.top))?;
            let selected = selection_idx == idx;
            let mut cw = CropWriter::new(w, width - 1); // -1 for scrollbar
            let txt_style = if selected { &styles.selected_line } else { &styles.default };
            if let Some(mount) = mounts.get(idx) {
                let match_style = if selected { &selected_match_style } else { match_style };
                let border_style = if selected { &selected_border_style } else { border_style };
                if con.show_selection_mark {
                    cw.queue_char(txt_style, if selected { '▶' } else { ' ' })?;
                }
                // fs
                let s = &mount.info.fs;
                let mut matched_string = MatchedString::new(
                    self.filtered.as_ref().and_then(|f| f.pattern.search_string(s)),
                    s,
                    txt_style,
                    match_style,
                );
                matched_string.fill(w_fs, Alignment::Left);
                matched_string.queue_on(&mut cw)?;
                cw.queue_char(border_style, '│')?;
                // dsk
                if e_dsk {
                    if let Some(disk) = mount.disk.as_ref() {
                        let s = disk.disk_type();
                        let mut matched_string = MatchedString::new(
                            self.filtered.as_ref().and_then(|f| f.pattern.search_string(s)),
                            s,
                            txt_style,
                            match_style,
                        );
                        matched_string.fill(5, Alignment::Center);
                        matched_string.queue_on(&mut cw)?;
                    } else {
                        cw.queue_g_string(txt_style, "     ".to_string())?;
                    }
                    cw.queue_char(border_style, '│')?;
                }
                // type
                if e_type {
                    let s = &mount.info.fs_type;
                    let mut matched_string = MatchedString::new(
                        self.filtered.as_ref().and_then(|f| f.pattern.search_string(s)),
                        s,
                        txt_style,
                        match_style,
                    );
                    matched_string.fill(w_type, Alignment::Center);
                    matched_string.queue_on(&mut cw)?;
                    cw.queue_char(border_style, '│')?;
                }
                // size, used, free
                if let Some(stats) = mount.stats().filter(|s| s.size() > 0) {
                    let share_color = super::share_color(stats.use_share());
                    // used
                    if e_use {
                        cw.queue_g_string(txt_style, format!("{:>4}", file_size::fit_4(stats.used())))?;
                        if e_use_share {
                            cw.queue_g_string(txt_style, format!("{:>3.0}%", 100.0*stats.use_share()))?;
                        }
                        if e_use_bar {
                            cw.queue_char(txt_style, ' ')?;
                            let pb = ProgressBar::new(stats.use_share() as f32, w_use_bar);
                            let mut bar_style = styles.default.clone();
                            bar_style.set_bg(share_color);
                            cw.queue_g_string(&bar_style, format!("{:<width$}", pb, width=w_use_bar))?;
                        }
                        cw.queue_char(border_style, '│')?;
                    }
                    // free
                    let mut share_style = txt_style.clone();
                    share_style.set_fg(share_color);
                    cw.queue_g_string(&share_style, format!("{:>4}", file_size::fit_4(stats.available())))?;
                    cw.queue_char(border_style, '│')?;
                    // size
                    if let Some(stats) = mount.stats() {
                        cw.queue_g_string(txt_style, format!("{:>4}", file_size::fit_4(stats.size())))?;
                    } else {
                        cw.repeat(txt_style, &SPACE_FILLING, 4)?;
                    }
                    cw.queue_char(border_style, '│')?;
                } else {
                    // used
                    if e_use {
                        cw.repeat(txt_style, &SPACE_FILLING, wc_use)?;
                        cw.queue_char(border_style, '│')?;
                    }
                    // free
                    cw.repeat(txt_style, &SPACE_FILLING, w_free)?;
                    cw.queue_char(border_style, '│')?;
                    // size
                    cw.repeat(txt_style, &SPACE_FILLING, w_size)?;
                    cw.queue_char(border_style, '│')?;
                }
                // mount point
                let s = &mount.info.mount_point.to_string_lossy();
                let matched_string = MatchedString::new(
                    self.filtered.as_ref().and_then(|f| f.pattern.search_string(s)),
                    s,
                    txt_style,
                    match_style,
                );
                matched_string.queue_on(&mut cw)?;
                idx += 1;
            }
            cw.fill(txt_style, &SPACE_FILLING)?;
            let scrollbar_style = if ScrollCommand::is_thumb(y, scrollbar) {
                &styles.scrollbar_thumb
            } else {
                &styles.scrollbar_track
            };
            scrollbar_style.queue_str(w, "▐")?;
        }
        Ok(())
    }

    fn on_internal(
        &mut self,
        w: &mut W,
        internal_exec: &InternalExecution,
        input_invocation: Option<&VerbInvocation>,
        trigger_type: TriggerType,
        app_state: &mut AppState,
        cc: &CmdContext,
    ) -> Result<CmdResult, ProgramError> {
        let screen = cc.app.screen;
        let con = &cc.app.con;
        use Internal::*;
        Ok(match internal_exec.internal {
            Internal::back => {
                if let Some(f) = self.filtered.take() {
                    if !f.mounts.is_empty() {
                        self.selection_idx = self.mounts.iter()
                            .position(|m| m.info.id == f.mounts[f.selection_idx].info.id)
                            .unwrap(); // all filtered mounts come from self.mounts
                    }
                    CmdResult::Keep
                } else {
                    CmdResult::PopState
                }
            }
            Internal::line_down => {
                self.move_line(internal_exec, input_invocation, 1, true)
            }
            Internal::line_up => {
                self.move_line(internal_exec, input_invocation, -1, true)
            }
            Internal::line_down_no_cycle => {
                self.move_line(internal_exec, input_invocation, 1, false)
            }
            Internal::line_up_no_cycle => {
                self.move_line(internal_exec, input_invocation, -1, false)
            }
            Internal::open_stay => {
                let in_new_panel = input_invocation
                    .map(|inv| inv.bang)
                    .unwrap_or(internal_exec.bang);
                let dam = Dam::unlimited();
                let mut tree_options = self.tree_options();
                tree_options.show_root_fs = true;
                CmdResult::from_optional_state(
                    BrowserState::new(
                        self.no_opt_selected_path().to_path_buf(),
                        tree_options,
                        screen,
                        con,
                        &dam,
                    ),
                    None,
                    in_new_panel,
                )
            }
            Internal::panel_left => {
                let areas = &cc.panel.areas;
                if areas.is_first() && areas.nb_pos < con.max_panels_count {
                    // we ask for the creation of a panel to the left
                    internal_focus::new_panel_on_path(
                        self.no_opt_selected_path().to_path_buf(),
                        screen,
                        self.tree_options(),
                        PanelPurpose::None,
                        con,
                        HDir::Left,
                    )
                } else {
                    // we ask the app to focus the panel to the left
                    CmdResult::HandleInApp(Internal::panel_left_no_open)
                }
            }
            Internal::panel_left_no_open => CmdResult::HandleInApp(Internal::panel_left_no_open),
            Internal::panel_right => {
                let areas = &cc.panel.areas;
                if areas.is_last() && areas.nb_pos < con.max_panels_count {
                    // we ask for the creation of a panel to the right
                    internal_focus::new_panel_on_path(
                        self.no_opt_selected_path().to_path_buf(),
                        screen,
                        self.tree_options(),
                        PanelPurpose::None,
                        con,
                        HDir::Right,
                    )
                } else {
                    // we ask the app to focus the panel to the right
                    CmdResult::HandleInApp(Internal::panel_right_no_open)
                }
            }
            Internal::panel_right_no_open => CmdResult::HandleInApp(Internal::panel_right_no_open),
            Internal::page_down => {
                if !self.try_scroll(ScrollCommand::Pages(1)) {
                    self.selection_idx = self.count() - 1;
                }
                CmdResult::Keep
            }
            Internal::page_up => {
                if !self.try_scroll(ScrollCommand::Pages(-1)) {
                    self.selection_idx = 0;
                }
                CmdResult::Keep
            }
            open_leave => CmdResult::PopStateAndReapply,
            _ => self.on_internal_generic(
                w,
                internal_exec,
                input_invocation,
                trigger_type,
                app_state,
                cc,
            )?,
        })
    }

source

pub fn try_scroll(&mut self, cmd: ScrollCommand) -> bool

Examples found in repository ?

src/filesystems/filesystems_state.rs (line 567)

    fn on_internal(
        &mut self,
        w: &mut W,
        internal_exec: &InternalExecution,
        input_invocation: Option<&VerbInvocation>,
        trigger_type: TriggerType,
        app_state: &mut AppState,
        cc: &CmdContext,
    ) -> Result<CmdResult, ProgramError> {
        let screen = cc.app.screen;
        let con = &cc.app.con;
        use Internal::*;
        Ok(match internal_exec.internal {
            Internal::back => {
                if let Some(f) = self.filtered.take() {
                    if !f.mounts.is_empty() {
                        self.selection_idx = self.mounts.iter()
                            .position(|m| m.info.id == f.mounts[f.selection_idx].info.id)
                            .unwrap(); // all filtered mounts come from self.mounts
                    }
                    CmdResult::Keep
                } else {
                    CmdResult::PopState
                }
            }
            Internal::line_down => {
                self.move_line(internal_exec, input_invocation, 1, true)
            }
            Internal::line_up => {
                self.move_line(internal_exec, input_invocation, -1, true)
            }
            Internal::line_down_no_cycle => {
                self.move_line(internal_exec, input_invocation, 1, false)
            }
            Internal::line_up_no_cycle => {
                self.move_line(internal_exec, input_invocation, -1, false)
            }
            Internal::open_stay => {
                let in_new_panel = input_invocation
                    .map(|inv| inv.bang)
                    .unwrap_or(internal_exec.bang);
                let dam = Dam::unlimited();
                let mut tree_options = self.tree_options();
                tree_options.show_root_fs = true;
                CmdResult::from_optional_state(
                    BrowserState::new(
                        self.no_opt_selected_path().to_path_buf(),
                        tree_options,
                        screen,
                        con,
                        &dam,
                    ),
                    None,
                    in_new_panel,
                )
            }
            Internal::panel_left => {
                let areas = &cc.panel.areas;
                if areas.is_first() && areas.nb_pos < con.max_panels_count {
                    // we ask for the creation of a panel to the left
                    internal_focus::new_panel_on_path(
                        self.no_opt_selected_path().to_path_buf(),
                        screen,
                        self.tree_options(),
                        PanelPurpose::None,
                        con,
                        HDir::Left,
                    )
                } else {
                    // we ask the app to focus the panel to the left
                    CmdResult::HandleInApp(Internal::panel_left_no_open)
                }
            }
            Internal::panel_left_no_open => CmdResult::HandleInApp(Internal::panel_left_no_open),
            Internal::panel_right => {
                let areas = &cc.panel.areas;
                if areas.is_last() && areas.nb_pos < con.max_panels_count {
                    // we ask for the creation of a panel to the right
                    internal_focus::new_panel_on_path(
                        self.no_opt_selected_path().to_path_buf(),
                        screen,
                        self.tree_options(),
                        PanelPurpose::None,
                        con,
                        HDir::Right,
                    )
                } else {
                    // we ask the app to focus the panel to the right
                    CmdResult::HandleInApp(Internal::panel_right_no_open)
                }
            }
            Internal::panel_right_no_open => CmdResult::HandleInApp(Internal::panel_right_no_open),
            Internal::page_down => {
                if !self.try_scroll(ScrollCommand::Pages(1)) {
                    self.selection_idx = self.count() - 1;
                }
                CmdResult::Keep
            }
            Internal::page_up => {
                if !self.try_scroll(ScrollCommand::Pages(-1)) {
                    self.selection_idx = 0;
                }
                CmdResult::Keep
            }
            open_leave => CmdResult::PopStateAndReapply,
            _ => self.on_internal_generic(
                w,
                internal_exec,
                input_invocation,
                trigger_type,
                app_state,
                cc,
            )?,
        })
    }

Trait Implementations§

source §

fn with_new_options(
    &mut self,
    _screen: Screen,
    change_options: &dyn Fn(&mut TreeOptions) -> &'static str,
    _in_new_panel: bool,
    _con: &AppContext
) -> CmdResult

Build a cmdResult in response to a command being a change of tree options. This may or not be a new state. Read more

source §

fn selection(&self) -> Option<Selection<'_>>

source §

fn refresh(&mut self, _screen: Screen, _con: &AppContext) -> Command

source §

fn on_pattern(
 &mut self,
 pattern: InputPattern,
 _app_state: &AppState,
 _con: &AppContext
) -> Result<CmdResult, ProgramError>

source §

fn display(
 &mut self,
 w: &mut W,
 disc: &DisplayContext<'_>
) -> Result<(), ProgramError>

source §

fn on_internal(
 &mut self,
 w: &mut W,
 internal_exec: &InternalExecution,
 input_invocation: Option<&VerbInvocation>,
 trigger_type: TriggerType<'_>,
 app_state: &mut AppState,
 cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

execute the internal with the optional given invocation. Read more

source §

fn on_click(
 &mut self,
 _x: u16,
 y: u16,
 _screen: Screen,
 _con: &AppContext
) -> Result<CmdResult, ProgramError>

source §

fn clear_pending(&mut self)

called on start of on_command

source §

fn on_double_click(
 &mut self,
 _x: u16,
 _y: u16,
 _screen: Screen,
 _con: &AppContext
) -> Result<CmdResult, ProgramError>

source §

fn on_mode_verb(&mut self, mode: Mode, con: &AppContext) -> CmdResult

source §

fn on_internal_generic(
 &mut self,
 _w: &mut W,
 internal_exec: &InternalExecution,
 input_invocation: Option<&VerbInvocation>,
 _trigger_type: TriggerType<'_>,
 app_state: &mut AppState,
 cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

a generic implementation of on_internal which may be called by states when they don’t have a specific behavior to execute

source §

fn stage(
 &self,
 app_state: &mut AppState,
 cc: &CmdContext<'_>,
 con: &AppContext
) -> CmdResult

source §

fn unstage(
 &self,
 app_state: &mut AppState,
 cc: &CmdContext<'_>,
 _con: &AppContext
) -> CmdResult

source §

fn toggle_stage(
 &self,
 app_state: &mut AppState,
 cc: &CmdContext<'_>,
 con: &AppContext
) -> CmdResult

source §

fn execute_verb(
 &mut self,
 w: &mut W,
 verb: &Verb,
 invocation: Option<&VerbInvocation>,
 trigger_type: TriggerType<'_>,
 app_state: &mut AppState,
 cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

source §

fn execute_external(
 &mut self,
 w: &mut W,
 verb: &Verb,
 external_execution: &ExternalExecution,
 invocation: Option<&VerbInvocation>,
 app_state: &mut AppState,
 cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

source §

fn execute_sequence(
 &mut self,
 _w: &mut W,
 verb: &Verb,
 seq_ex: &SequenceExecution,
 invocation: Option<&VerbInvocation>,
 app_state: &mut AppState,
 _cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

source §

fn on_command(
 &mut self,
 w: &mut W,
 app_state: &mut AppState,
 cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

change the state, does no rendering

source §

fn open_preview(
 &mut self,
 prefered_mode: Option<PreviewMode>,
 close_if_open: bool,
 cc: &CmdContext<'_>
) -> CmdResult

return a cmdresult asking for the opening of a preview

source §

fn tree_root(&self) -> Option<&Path>

must return None if the state doesn’t display a file tree

source §

fn sel_info<'c>(&'c self, _app_state: &'c AppState) -> SelInfo<'c>

source §

fn has_at_least_one_selection(&self, _app_state: &AppState) -> bool

source §

fn do_pending_task(
 &mut self,
 _app_state: &mut AppState,
 _screen: Screen,
 _con: &AppContext,
 _dam: &mut Dam
) -> Result<(), ProgramError>

source §

fn get_pending_task(&self) -> Option<&'static str>

source §

fn get_flags(&self) -> Vec<Flag> ⓘ

return the flags to display

source §

fn get_starting_input(&self) -> String

source §

fn set_selected_path(&mut self, _path: PathBuf, _con: &AppContext)

source §

fn no_verb_status(&self, _has_previous_state: bool, _con: &AppContext) -> Status

return the status which should be used when there’s no verb edited

source §

fn get_status(
 &self,
 app_state: &AppState,
 cc: &CmdContext<'_>,
 has_previous_state: bool
) -> Status

source §

fn get_verb_status(
 &self,
 verb: &Verb,
 invocation: &VerbInvocation,
 sel_info: SelInfo<'_>,
 _cc: &CmdContext<'_>,
 app_state: &AppState
) -> Status

Auto Trait Implementations§

§

impl RefUnwindSafe for FilesystemState

§

impl Send for FilesystemState

§

impl Sync for FilesystemState

§

impl Unpin for FilesystemState

§

impl UnwindSafe for FilesystemState

Blanket Implementations§

source §

impl<T> Any for Twhere
T: 'static + ?Sized,

source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source §

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source §

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source §

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source §

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pointable for T

§

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

§

type Init = T

The type for initializers.

§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

source §

impl<T, U> TryFrom for Twhere
U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source §

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

§

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct broot::filesystems::FilesystemState

Implementations§

impl FilesystemState

pub fn new( path: Option<&Path>, tree_options: TreeOptions, con: &AppContext) -> Result<FilesystemState, ProgramError>

pub fn count(&self) -> usize

pub fn try_scroll(&mut self, cmd: ScrollCommand) -> bool

Trait Implementations§

impl PanelState for FilesystemState

fn get_type(&self) -> PanelStateType

fn set_mode(&mut self, mode: Mode)

fn get_mode(&self) -> Mode

fn selected_path(&self) -> Option<&Path>

fn tree_options(&self) -> TreeOptions

fn with_new_options( &mut self, _screen: Screen, change_options: &dyn Fn(&mut TreeOptions) -> &'static str, _in_new_panel: bool, _con: &AppContext) -> CmdResult

fn selection(&self) -> Option<Selection<'_>>

fn refresh(&mut self, _screen: Screen, _con: &AppContext) -> Command

fn on_pattern( &mut self, pattern: InputPattern, _app_state: &AppState, _con: &AppContext) -> Result<CmdResult, ProgramError>

fn display( &mut self, w: &mut W, disc: &DisplayContext<'_>) -> Result<(), ProgramError>

fn on_internal( &mut self, w: &mut W, internal_exec: &InternalExecution, input_invocation: Option<&VerbInvocation>, trigger_type: TriggerType<'_>, app_state: &mut AppState, cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn on_click( &mut self, _x: u16, y: u16, _screen: Screen, _con: &AppContext) -> Result<CmdResult, ProgramError>

fn clear_pending(&mut self)

fn on_double_click( &mut self, _x: u16, _y: u16, _screen: Screen, _con: &AppContext) -> Result<CmdResult, ProgramError>

fn on_mode_verb(&mut self, mode: Mode, con: &AppContext) -> CmdResult

fn on_internal_generic( &mut self, _w: &mut W, internal_exec: &InternalExecution, input_invocation: Option<&VerbInvocation>, _trigger_type: TriggerType<'_>, app_state: &mut AppState, cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn stage( &self, app_state: &mut AppState, cc: &CmdContext<'_>, con: &AppContext) -> CmdResult

fn unstage( &self, app_state: &mut AppState, cc: &CmdContext<'_>, _con: &AppContext) -> CmdResult

fn toggle_stage( &self, app_state: &mut AppState, cc: &CmdContext<'_>, con: &AppContext) -> CmdResult

fn execute_verb( &mut self, w: &mut W, verb: &Verb, invocation: Option<&VerbInvocation>, trigger_type: TriggerType<'_>, app_state: &mut AppState, cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn execute_external( &mut self, w: &mut W, verb: &Verb, external_execution: &ExternalExecution, invocation: Option<&VerbInvocation>, app_state: &mut AppState, cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn execute_sequence( &mut self, _w: &mut W, verb: &Verb, seq_ex: &SequenceExecution, invocation: Option<&VerbInvocation>, app_state: &mut AppState, _cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn on_command( &mut self, w: &mut W, app_state: &mut AppState, cc: &CmdContext<'_>) -> Result<CmdResult, ProgramError>

fn open_preview( &mut self, prefered_mode: Option<PreviewMode>, close_if_open: bool, cc: &CmdContext<'_>) -> CmdResult

fn tree_root(&self) -> Option<&Path>

fn sel_info<'c>(&'c self, _app_state: &'c AppState) -> SelInfo<'c>

fn has_at_least_one_selection(&self, _app_state: &AppState) -> bool

fn do_pending_task( &mut self, _app_state: &mut AppState, _screen: Screen, _con: &AppContext, _dam: &mut Dam) -> Result<(), ProgramError>

fn get_pending_task(&self) -> Option<&'static str>

fn get_flags(&self) -> Vec<Flag> ⓘ

fn get_starting_input(&self) -> String

fn set_selected_path(&mut self, _path: PathBuf, _con: &AppContext)

fn no_verb_status(&self, _has_previous_state: bool, _con: &AppContext) -> Status

fn get_status( &self, app_state: &AppState, cc: &CmdContext<'_>, has_previous_state: bool) -> Status

fn get_verb_status( &self, verb: &Verb, invocation: &VerbInvocation, sel_info: SelInfo<'_>, _cc: &CmdContext<'_>, app_state: &AppState) -> Status

Auto Trait Implementations§

impl RefUnwindSafe for FilesystemState

impl Send for FilesystemState

impl Sync for FilesystemState

impl Unpin for FilesystemState

impl UnwindSafe for FilesystemState

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

pub fn new(
path: Option<&Path>,
tree_options: TreeOptions,
con: &AppContext
) -> Result<FilesystemState, ProgramError>

fn with_new_options(
&mut self,
_screen: Screen,
change_options: &dyn Fn(&mut TreeOptions) -> &'static str,
_in_new_panel: bool,
_con: &AppContext
) -> CmdResult

fn on_pattern(
&mut self,
pattern: InputPattern,
_app_state: &AppState,
_con: &AppContext
) -> Result<CmdResult, ProgramError>

fn display(
&mut self,
w: &mut W,
disc: &DisplayContext<'_>
) -> Result<(), ProgramError>

fn on_internal(
&mut self,
w: &mut W,
internal_exec: &InternalExecution,
input_invocation: Option<&VerbInvocation>,
trigger_type: TriggerType<'_>,
app_state: &mut AppState,
cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn on_click(
&mut self,
_x: u16,
y: u16,
_screen: Screen,
_con: &AppContext
) -> Result<CmdResult, ProgramError>

fn on_double_click(
&mut self,
_x: u16,
_y: u16,
_screen: Screen,
_con: &AppContext
) -> Result<CmdResult, ProgramError>

fn on_internal_generic(
&mut self,
_w: &mut W,
internal_exec: &InternalExecution,
input_invocation: Option<&VerbInvocation>,
_trigger_type: TriggerType<'_>,
app_state: &mut AppState,
cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn stage(
&self,
app_state: &mut AppState,
cc: &CmdContext<'_>,
con: &AppContext
) -> CmdResult

fn unstage(
&self,
app_state: &mut AppState,
cc: &CmdContext<'_>,
_con: &AppContext
) -> CmdResult

fn toggle_stage(
&self,
app_state: &mut AppState,
cc: &CmdContext<'_>,
con: &AppContext
) -> CmdResult

fn execute_verb(
&mut self,
w: &mut W,
verb: &Verb,
invocation: Option<&VerbInvocation>,
trigger_type: TriggerType<'_>,
app_state: &mut AppState,
cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn execute_external(
&mut self,
w: &mut W,
verb: &Verb,
external_execution: &ExternalExecution,
invocation: Option<&VerbInvocation>,
app_state: &mut AppState,
cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn execute_sequence(
&mut self,
_w: &mut W,
verb: &Verb,
seq_ex: &SequenceExecution,
invocation: Option<&VerbInvocation>,
app_state: &mut AppState,
_cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn on_command(
&mut self,
w: &mut W,
app_state: &mut AppState,
cc: &CmdContext<'_>
) -> Result<CmdResult, ProgramError>

fn open_preview(
&mut self,
prefered_mode: Option<PreviewMode>,
close_if_open: bool,
cc: &CmdContext<'_>
) -> CmdResult

fn do_pending_task(
&mut self,
_app_state: &mut AppState,
_screen: Screen,
_con: &AppContext,
_dam: &mut Dam
) -> Result<(), ProgramError>

fn get_status(
&self,
app_state: &AppState,
cc: &CmdContext<'_>,
has_previous_state: bool
) -> Status

fn get_verb_status(
&self,
verb: &Verb,
invocation: &VerbInvocation,
sel_info: SelInfo<'_>,
_cc: &CmdContext<'_>,
app_state: &AppState
) -> Status

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,