Struct Split 

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

Splits the area in multiple parts and renders a UI that allows changing the sizes.

• Can hide/show regions.
• Resize
  • neighbours only
  • all regions
• Horizontal / vertical split. Choose one.

The widget doesn’t hold references to the content widgets, instead it gives back the regions where the content can be rendered.

1. Construct the Split.
2. Call Split::into_widgets to create the actual widget and the layout of the regions.
3. Render the content areas.
4. Render the split widget last. There are options that will render above the widgets and use part of the content area.

Implementations

impl<'a> Split<'a>

pub fn new() -> Self

Create a new split.

To have any split-areas you must set a list of [constraints] for both the number and initial sizes of the areas.

pub fn horizontal() -> Self

Horizontal split.

pub fn vertical() -> Self

Vertical split

pub fn constraints( self, constraints: impl IntoIterator<Item = Constraint>, ) -> Self

Set constraints for the initial area sizes. If the window is resized the current widths are used as constraints for recalculating.

The number of constraints determines the number of areas.

pub fn resize_constraint(self, n: usize, constraint: ResizeConstraint) -> Self

Set the behaviour for each area when resizing the split-widget itself.

pub fn direction(self, direction: Direction) -> Self

Layout direction of the widgets. Direction::Horizontal means the widgets are laid out left to right, with a vertical split area in between.

pub fn split_type(self, split_type: SplitType) -> Self

Controls rendering of the splitter.

pub fn resize(self, resize: SplitResize) -> Self

Controls resizing the split areas.

pub fn join(self, border: BorderType) -> Self

Draw a join character between the split and the borders. This sets the border type used for the surrounding border.

pub fn join_0(self, border: BorderType) -> Self

Draw a join character between the split and the border on the left/top side. This sets the border type used for the left/top border.

pub fn join_1(self, border: BorderType) -> Self

Draw a join character between the split and the border on the right/bottom side. This sets the border type used for the right/bottom border.

pub fn block(self, block: Block<'a>) -> Self

Outer block.

pub fn styles(self, styles: SplitStyle) -> Self

Set all styles.

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

Style for the split area.

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

Style for the arrows.

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

Style while dragging the splitter.

pub fn mark_offset(self, offset: u16) -> Self

Offset for the split marker from the top/left.

pub fn mark_0(self, mark: &'a str) -> Self

First marker char for the splitter.

pub fn mark_1(self, mark: &'a str) -> Self

Second marker char for the splitter.

pub fn into_widget(self, area: Rect, state: &mut SplitState) -> SplitWidget<'a>

👎Deprecated since 2.4.0: use into_widgets() instead

Constructs the widget for rendering.

Returns the SplitWidget that actually renders the split decorations.

Use SplitState::widget_areas to render your contents, and then render the SplitWidget. This allows it to render some decorations on top of your widgets.

pub fn into_widget_layout( self, area: Rect, state: &mut SplitState, ) -> (SplitWidget<'a>, Vec<Rect>)

👎Deprecated since 2.4.0: use into_widgets() instead

Constructs the widgets for rendering.

Returns the SplitWidget that actually renders the split. Returns a Vec<Rect> with the regions for each split.

Render your content first, using the layout information. And the SplitWidget as last to allow rendering over the content widgets.

pub fn into_widgets(self) -> (LayoutWidget<'a>, SplitWidget<'a>)

Constructs the widgets for rendering.

Returns the LayoutWidget that must run first. It doesn’t actually render anything, it just calculates the layout for the split regions.

Use the layout in SplitState::widget_areas to render your widgets.

The SplitWidget actually renders the split itself. Render it after you finished with the content.

Trait Implementations

impl<'a> Clone for Split<'a>

fn clone(&self) -> Split<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Split<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Split<'a>

fn default() -> Split<'a>

Returns the “default value” for a type.

impl<'a> StatefulWidget for &Split<'a>

type State = SplitState

State associated with the stateful widget.

fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom stateful widget.

impl<'a> StatefulWidget for Split<'a>

type State = SplitState

State associated with the stateful widget.

fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom stateful widget.