Trait broot::app::AppState[−][src]

pub trait AppState {
    fn set_mode(&mut self, mode: Mode);

    fn get_mode(&self) -> Mode;

    fn on_internal(
        &mut self, 
        w: &mut W, 
        internal_exec: &InternalExecution, 
        input_invocation: Option<&VerbInvocation>, 
        trigger_type: TriggerType, 
        cc: &CmdContext<'_>, 
        screen: Screen
    ) -> Result<AppStateCmdResult, ProgramError>;

    fn selected_path(&self) -> &Path;

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

    fn refresh(&mut self, screen: Screen, con: &AppContext) -> Command;

    fn tree_options(&self) -> TreeOptions;

    fn with_new_options(
        &mut self, 
        screen: Screen, 
        change_options: &dyn Fn(&mut TreeOptions), 
        in_new_panel: bool, 
        con: &AppContext
    ) -> AppStateCmdResult;

    fn display(
        &mut self, 
        w: &mut W, 
        screen: Screen, 
        state_area: Area, 
        skin: &PanelSkin, 
        con: &AppContext
    ) -> Result<(), ProgramError>;

    fn clear_pending(&mut self) { ... }

    fn on_click(
        &mut self, 
        _x: u16, 
        _y: u16, 
        _screen: Screen, 
        _con: &AppContext
    ) -> Result<AppStateCmdResult, ProgramError> { ... }

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

    fn on_pattern(
        &mut self, 
        _pat: InputPattern, 
        _con: &AppContext
    ) -> Result<AppStateCmdResult, ProgramError> { ... }

    fn on_mode_verb(
        &mut self, 
        mode: Mode, 
        con: &AppContext
    ) -> AppStateCmdResult { ... }

    fn on_internal_generic(
        &mut self, 
        _w: &mut W, 
        internal_exec: &InternalExecution, 
        input_invocation: Option<&VerbInvocation>, 
        _trigger_type: TriggerType, 
        cc: &CmdContext<'_>, 
        screen: Screen
    ) -> Result<AppStateCmdResult, ProgramError> { ... }

    fn execute_verb(
        &mut self, 
        w: &mut W, 
        verb: &Verb, 
        invocation: Option<&VerbInvocation>, 
        trigger_type: TriggerType, 
        cc: &CmdContext<'_>, 
        screen: Screen
    ) -> Result<AppStateCmdResult, ProgramError> { ... }

    fn on_command(
        &mut self, 
        w: &mut W, 
        cc: &CmdContext<'_>, 
        screen: Screen
    ) -> Result<AppStateCmdResult, ProgramError> { ... }

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

    fn do_pending_task(
        &mut self, 
        _screen: Screen, 
        _con: &AppContext, 
        _dam: &mut Dam
    ) { ... }

    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, 
        cmd: &Command, 
        other_path: &Option<PathBuf>, 
        has_previous_state: bool, 
        con: &AppContext
    ) -> Status { ... }
}

a panel state, stackable to allow reverting to a previous one

Required methods

fn set_mode(&mut self, mode: Mode)[src]

fn get_mode(&self) -> Mode[src]

fn on_internal(
    &mut self,
    w: &mut W,
    internal_exec: &InternalExecution,
    input_invocation: Option<&VerbInvocation>,
    trigger_type: TriggerType,
    cc: &CmdContext<'_>,
    screen: Screen
) -> Result<AppStateCmdResult, ProgramError>[src]

execute the internal with the optional given invocation.

The invocation comes from the input and may be related to a different verb (the verb may have been triggered by a key shorctut)

fn selected_path(&self) -> &Path[src]

fn selection(&self) -> Selection<'_>[src]

fn refresh(&mut self, screen: Screen, con: &AppContext) -> Command[src]

fn tree_options(&self) -> TreeOptions[src]

fn with_new_options(
    &mut self,
    screen: Screen,
    change_options: &dyn Fn(&mut TreeOptions),
    in_new_panel: bool,
    con: &AppContext
) -> AppStateCmdResult[src]

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

fn display(
    &mut self,
    w: &mut W,
    screen: Screen,
    state_area: Area,
    skin: &PanelSkin,
    con: &AppContext
) -> Result<(), ProgramError>[src]

Loading content...

Provided methods

fn clear_pending(&mut self)[src]

called on start of on_command

fn on_click(
    &mut self,
    _x: u16,
    _y: u16,
    _screen: Screen,
    _con: &AppContext
) -> Result<AppStateCmdResult, ProgramError>[src]

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

fn on_pattern(
    &mut self,
    _pat: InputPattern,
    _con: &AppContext
) -> Result<AppStateCmdResult, ProgramError>[src]

fn on_mode_verb(&mut self, mode: Mode, con: &AppContext) -> AppStateCmdResult[src]

fn on_internal_generic(
    &mut self,
    _w: &mut W,
    internal_exec: &InternalExecution,
    input_invocation: Option<&VerbInvocation>,
    _trigger_type: TriggerType,
    cc: &CmdContext<'_>,
    screen: Screen
) -> Result<AppStateCmdResult, ProgramError>[src]

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

fn execute_verb(
    &mut self,
    w: &mut W,
    verb: &Verb,
    invocation: Option<&VerbInvocation>,
    trigger_type: TriggerType,
    cc: &CmdContext<'_>,
    screen: Screen
) -> Result<AppStateCmdResult, ProgramError>[src]

fn on_command(
    &mut self,
    w: &mut W,
    cc: &CmdContext<'_>,
    screen: Screen
) -> Result<AppStateCmdResult, ProgramError>[src]

change the state, does no rendering

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

return a cmdresult asking for the opening of a preview

fn do_pending_task(
    &mut self,
    _screen: Screen,
    _con: &AppContext,
    _dam: &mut Dam
)[src]

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

fn get_flags(&self) -> Vec<Flag>[src]

return the flags to display

fn get_starting_input(&self) -> String[src]

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

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

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

fn get_status(
    &self,
    cmd: &Command,
    other_path: &Option<PathBuf>,
    has_previous_state: bool,
    con: &AppContext
) -> Status[src]

Loading content...

Implementors

impl AppState for BrowserState[src]

fn with_new_options(
    &mut self,
    screen: Screen,
    change_options: &dyn Fn(&mut TreeOptions),
    in_new_panel: bool,
    con: &AppContext
) -> AppStateCmdResult[src]

build a cmdResult asking for the addition of a new state being a browser state similar to the current one but with different options

fn do_pending_task(&mut self, screen: Screen, con: &AppContext, dam: &mut Dam)[src]

do some work, totally or partially, if there’s some to do. Stop as soon as the dam asks for interruption

impl AppState for FilesystemState[src]

impl AppState for HelpState[src]

impl AppState for PreviewState[src]

fn do_pending_task(&mut self, _screen: Screen, con: &AppContext, dam: &mut Dam)[src]

do the preview filtering if required and not yet done

Loading content...