Struct InternalSettings 

pub struct InternalSettings {
    pub force_clear: bool,
    pub must_quit: bool,
    pub nvim_server: String,
    pub opener: Opener,
    pub size: Size,
    pub disks: Disks,
    pub inside_neovim: bool,
    pub copy_file_queue: Vec<(Vec<PathBuf>, PathBuf)>,
    pub in_mem_progress: Option<InMemoryTerm>,
    pub clear_before_quit: bool,
    pub cursor: Cursor,
    pub last_buffer: Option<Buffer>,
    /* private fields */
}

Internal settings of the status.

Every setting which couldn’t be attached elsewhere and is needed by the whole application. It knows:

• if the content should be completely refreshed,
• if the application has to quit,
• the address of the nvim_server to send files to and if the application was launched from neovim,
• which opener should be used for kind of files,
• the height & width of the application,
• basic informations about disks being used,
• a copy queue to display informations about files beeing copied.

Fields

force_clear: bool

Do we have to clear the screen ?

must_quit: bool

True if the user issued a quit event (Key::Char('q') by default). It’s used to exit the main loop before reseting the cursor.

nvim_server: String

NVIM RPC server address

opener: Opener

The opener used by the application.

size: Size

Termin size, width & height

disks: Disks

Info about the running machine. Only used to detect disks and their mount points.

inside_neovim: bool

true if the application was launched inside a neovim terminal emulator

copy_file_queue: Vec<(Vec<PathBuf>, PathBuf)>

queue of pairs (sources, dest) to be copied. it shouldn’t be massive under normal usage so we can use a vector instead of an efficient queue data structure.

in_mem_progress: Option<InMemoryTerm>

internal progressbar used to display copy progress

clear_before_quit: bool

true if the terminal should be cleared before exit. It’s set to true when we reuse the window to start a new shell.

cursor: Cursor

Cesor movement and selection. Responsible of recording what is selected by the user.

last_buffer: Option<Buffer>

Last registered frame

Implementations

impl InternalSettings

pub fn new(opener: Opener, size: Size, disks: Disks, binds: &Bindings) -> Self

Creates a new instance. Some parameters (nvim_server and inside_neovim) are read from args.

pub fn term_size(&self) -> Size

Returns the size of the terminal (width, height)

pub fn update_size(&mut self, width: u16, height: u16)

Update the size from width & height.

pub fn force_clear(&mut self)

Set a “force clear” flag to true, which will reset the display. It’s used when some command or whatever may pollute the terminal. We ensure to clear it before displaying again.

pub fn reset_clear(&mut self)

Reset the clear flag. Prevent the display from being completely reset for the next frame.

pub fn should_be_cleared(&self) -> bool

True iff some event required a complete refresh of the dispplay

pub fn disks(&mut self) -> &Disks

Refresh the disks – removing non listed ones – and returns a reference

pub fn mount_points_vec(&mut self) -> Vec<&Path>

Returns a vector of mount points. Disks are refreshed first.

pub fn mount_points_set(&self) -> HashSet<&Path>

Returns a set of mount points

pub fn update_nvim_listen_address(&mut self)

Tries its best to update the neovim address.

1. from the $NVIM_LISTEN_ADDRESS environment variable,
2. from the opened socket read from ss.

Warning

If multiple neovim instances are opened at the same time, it will get the first one from the ss output.

pub fn copy_file_remove_head(&mut self) -> Result<()>

Remove the top of the copy queue.

pub fn copy_next_file_in_queue( &mut self, fm_sender: Arc<Sender<FmEvents>>, width: u16, ) -> Result<()>

Start the copy of the next file in copy file queue and register the progress in the mock terminal used to create the display.

pub fn store_copy_progress(&mut self, in_mem_progress_bar: InMemoryTerm)

Store copy progress bar. When a copy progress bar is stored, display manager is responsible for its display in the left tab.

pub fn unset_copy_progress(&mut self)

Set copy progress bar to None.

pub fn disable_display(&mut self)

Disable the application display. It’s used to give to allow another program to be executed.

pub fn enable_display(&mut self)

Display the application after it gave its terminal to another program.

Enable the display again, clear the screen, set a flag to clear before quitting application.

pub fn is_disabled(&self) -> bool

True iff the terminal is disabled. The state (self.is_disabled) is changed every time a new shell is started replacing the normal window. If true, the display shouldn’t be drawn.

pub fn open_in_window<P>( &mut self, args: &[&str], current_path: P, ) -> Result<()>

where P: AsRef<Path>,

Open a new command which output will replace the current display. Current progress of the application is locked as long as the command doesn’t finish. Firstly the display is disabled, then the command is ran. Once the command ends… the display is reenabled again.

pub fn open_single_file<P>( &mut self, path: &Path, current_path: P, ) -> Result<()>

where P: AsRef<Path>,

Open a single file: In neovim if this file should be, or in a new shell in current terminal, or in a new window.

pub fn open_flagged_files<P>( &mut self, flagged: &Flagged, current_path: P, ) -> Result<()>

where P: AsRef<Path>,

Open all the flagged files. We try to open all files in a single command if it’s possible. If all files should be opened in neovim, it will be. Otherwise, they will be opened separetely.

pub fn quit(&mut self)

Set the must quit flag to true. The next update call will exit the application. It doesn’t exit the application itself.

pub fn format_copy_progress(&self) -> Option<String>

Format the progress of the current operation in copy file queue. If nothing is being copied, it returns None

pub fn move_cursor(&mut self, direction: CursorDirection)

Move the cursor in given direction, up, down, left or right. Cursor is clamped to the the screen and can’t move outside. Extends the selection if the cursor is active.

pub fn copy_buffer_rect(&self)

Copy the rect buffer of text in the clipboard.