Struct Split 

pub struct Split<'a, M> { /* private fields */ }

Two children side by side (Split::horizontal) or one above the other (Split::vertical), with a border between them. The border drags with the mouse (#476’s preview border, generalised, #479) and moves with Alt+H/Alt+L (side by side) or Alt+K/Alt+J (stacked); each pane keeps its minimum size. Tab moves focus between the panes.

Implementations

impl<'a, M> Split<'a, M>

pub fn horizontal( left: impl Component<Output = M> + 'a, right: impl Component<Output = M> + 'a, ) -> Split<'a, M>

left and right, side by side.

pub fn vertical( top: impl Component<Output = M> + 'a, bottom: impl Component<Output = M> + 'a, ) -> Split<'a, M>

top above bottom. The split takes the whole height.

pub fn ratio(self, percent: u8) -> Self

The first pane’s share, in percent, until the border is moved (default 50).

pub fn at(self, cells: usize) -> Self

Put the border after cells of the first pane, until moved.

pub fn min(self, cells: usize) -> Self

Both panes at least cells along the axis (default 1).

pub fn mins(self, first: usize, second: usize) -> Self

The first pane at least first cells and the second at least second.

pub fn style(self, style: Style) -> Self

The border’s style (default: the theme’s, dim).

pub fn on( self, action: &str, keys: impl IntoIterator<Item = Key>, description: &str, handler: impl FnMut() -> Flow<M> + 'a, ) -> Self

Run handler when one of keys bubbles up unused by the focused child: an action of yours, listed in the keymap under this container’s context.

pub fn shortcut( self, action: &str, keys: impl IntoIterator<Item = Key>, description: &str, handler: impl FnMut() -> Flow<M> + 'a, ) -> Self

Run handler when one of keys is pressed, before the focused child sees it.

pub fn rebind(self, action: &str, keys: impl IntoIterator<Item = Key>) -> Self

Make keys do this container’s action (focus-next, and the container’s own); no keys unbinds it.

pub fn own_keymap(&self) -> &Keymap

This container’s own bindings, without its children’s.

pub fn with_mouse(self, on: bool) -> Self

Report the mouse even when no child asks for it: for a click to focus a child, or a border to drag.

pub fn axis(&self) -> Axis

pub fn divider(&self) -> &Divider

The border: where it is, whether it is being dragged.

pub fn first(&self) -> &(dyn Component<Output = M> + 'a)

pub fn second(&self) -> &(dyn Component<Output = M> + 'a)

pub fn first_mut(&mut self) -> &mut (dyn Component<Output = M> + 'a)

pub fn second_mut(&mut self) -> &mut (dyn Component<Output = M> + 'a)

pub fn focused(&self) -> Option<usize>

The focused pane: 0 or 1.

pub fn focus(&mut self, index: usize) -> bool

Focus pane index (0 or 1), if it takes focus.

pub fn layout(&self, context: &Context<'_>) -> [Rect; 2]

The two panes’ rectangles at context’s size.

Trait Implementations

impl<M> Component for Split<'_, M>

type Output = M

fn start(&mut self, context: &Context<'_>) -> Flow<M>

Called once, before the component is first painted, with the terminal’s size: for work that needs it, such as rendering content at the width. Returning Done or Cancel finishes the component without waiting for an event. The default does nothing.

fn handle(&mut self, event: &Event, context: &Context<'_>) -> Flow<M>

Handle one event. Ctrl+C never arrives here: the event loop ends the component with Outcome::Interrupted.

fn render(&self, context: &Context<'_>) -> View

Render the current state.

fn tick(&self) -> Option<Duration>

How often the component wants Event::Tick, for a spinner or a countdown. None (the default): never.

fn mouse(&self) -> bool

Whether the component wants mouse events (#476): clicks, drags and the wheel. Off by default, since reporting the mouse takes text selection away from the terminal; a component turns it on when its caller opts in, and run then enables mouse reporting for the session.

fn keymap(&self) -> Keymap

The bindings this component has right now, for a help overlay, a shortcut list or status-bar hints to read (see keymap). A container’s include its focused child’s, before its own. The default declares none.

fn focusable(&self) -> bool

Whether the component takes focus in a container: Tab stops on it and keys go to it. The default: yes. A label, or a component that has finished, says no.

fn focus_step(&mut self, forward: bool) -> bool

Move focus to the next (forward) or previous focus stop inside this component, for Tab and Shift+Tab. false when there is none after the current one, so the container moves on to its next child. The default, for a component that is one stop: false.

fn focus_enter(&mut self, forward: bool) -> bool

Take focus from outside: at the first stop inside when forward, at the last otherwise. false when nothing in it can take focus. The default: whether the component is focusable.

fn default_value(&self) -> Option<Self::Output>

The value to return when the terminal is not interactive and the policy asks for defaults. None: there is none.

fn prompt( &mut self, io: &mut dyn LineIo, ) -> Result<Option<Self::Output>, NotInteractive>

Ask for the value line by line, for when the terminal is not interactive and the policy asks for a prompt. The default says the component has no line-based form.