Struct SplitState 

pub struct SplitState {

    pub area: Rect,
    pub inner: Rect,
    pub widget_areas: Vec<Rect>,
    pub splitline_areas: Vec<Rect>,
    pub splitline_mark_position: Vec<Position>,
    pub mark_offset: u16,
    pub direction: Direction,
    pub split_type: SplitType,
    pub resize: SplitResize,
    pub focus: FocusFlag,
    pub focus_marker: Option<usize>,
    pub mouse: MouseFlagsN,
    pub non_exhaustive: NonExhaustive,
    /* private fields */
}

State & event handling.

Fields

area: Rect

Total area. readonly. renewed for each render.

inner: Rect

Area inside the border. readonly. renewed for each render.

widget_areas: Vec<Rect>

The widget areas. Use this after calling layout() to render your widgets. readonly renewed for each render.

splitline_areas: Vec<Rect>

Area used by the splitter. This is area is used for moving the splitter. It might overlap with the widget area. readonly renewed for each render.

splitline_mark_position: Vec<Position>

Start position for drawing the mark. readonly renewed for each render.

mark_offset: u16

Offset of the mark from top/left. readonly renewed for each render.

direction: Direction

Direction of the split. readonly renewed for each render.

split_type: SplitType

readonly renewed for each render.

resize: SplitResize

readonly renewed for each render.

focus: FocusFlag

Focus. read+write

focus_marker: Option<usize>

If the splitter has the focus you can navigate between the split-markers. This is the currently active split-marker. read+write

mouse: MouseFlagsN

Mouseflags. read+write

non_exhaustive: NonExhaustive

Implementations

impl SplitState

pub fn new() -> Self

New state.

pub fn named(name: &str) -> Self

New state with a focus-name.

pub fn set_screen_split_pos(&mut self, n: usize, pos: (u16, u16)) -> bool

Set the position for the nth splitter.

The position is limited the combined area of the two adjacent areas. The position is further limited to leave space for rendering the splitter.

pub fn move_split_left(&mut self, n: usize, delta: u16) -> bool

Move the nth split position. If delta is greater than the area length it sets the length to 0.

pub fn move_split_right(&mut self, n: usize, delta: u16) -> bool

Move the nth split position. Does nothing if the change is bigger than the length of the split.

pub fn move_split_up(&mut self, n: usize, delta: u16) -> bool

Move the nth split position. Does nothing if the change is bigger than the length of the split.

pub fn move_split_down(&mut self, n: usize, delta: u16) -> bool

Move the nth split position. Does nothing if the change is bigger than the length of the split.

pub fn select_next_split(&mut self) -> bool

Select the next splitter for manual adjustment.

pub fn select_prev_split(&mut self) -> bool

Select the previous splitter for manual adjustment.

pub fn len(&self) -> usize

Number of split-areas

pub fn area_lengths(&self) -> &[u16]

Get all area lengths.

pub fn set_area_lengths(&mut self, lengths: Vec<u16>)

Set all area lengths.

This will adjust the list of the hidden splits too.

Caution If the sum of the lengths doesn’t match the display-width this will trigger a layout and will use the given lenghts as Constraint::Fill().

Caution

If a length is 0 it will not display the split at all.

pub fn hidden_lengths(&self) -> &[u16]

Get the value of the hidden lengths.

pub fn set_hidden_lengths(&mut self, hidden: Vec<u16>)

Set the value of the hidden lengths.

This will take at most area_length.len() items of this Vec. And it will fill missing items as 0.

pub fn area_len(&self, n: usize) -> u16

Length of the nth split.

Caution

This length includes the width of the split itself. Which may or may not take some space. Except for the last. So it will be better to use widget_areas for anything rendering related.

pub fn total_area_len(&self) -> u16

Sum of all area lengths.

pub fn set_area_len(&mut self, n: usize, len: u16)

Set the length of the nth split.

This resets any hidden state of the nth split.

Caution The sum of all lengths must be equal with the width/height of the splitter. If it is not this operation doesn’t set the absolute width of the nth split. Instead, it triggers a layout of the widget, takes all the lengths as Constraint::Fill() values and redistributes the size.

You can either ensure to change some other len to accommodate for your changes. Or use set_split_pos or set_screen_split_pos

Caution

This length includes the width of the split itself. Which may or may not take some space. Except for the last area. Which doesn’t have a split.

So:

• If you set the length to 0 the area will be hidden completely and no split will be shown.
• A value of 1 is fine.
• The last area can have a length 0 and that’s fine too.

Caution

Before the first render this will do nothing. Use set_area_lengths to initialize the areas.

pub fn split_pos(&self, n: usize) -> u16

Returns the position of the nth split.

Caution

The numbering for the splitters goes from 0 to len-1 exclusive. Split n marks the gap between area n and n+1.

Caution

This returns the position of the gap between two adjacent split-areas. Use splitline_areas for anything rendering related.

pub fn set_split_pos(&mut self, n: usize, pos: u16)

Sets the position of the nth split.

Depending on the resize strategy this can limit the allowed positions for the split.

Caution

The numbering for the splitters goes from 0 to len-1 exclusive. Split n marks the gap between area n and n+1.

Caution

This marks the position of the gap between two adjacent split-areas. If you start from screen-coordinates it might be easier to use set_screen_split_pos

pub fn is_hidden(&self, n: usize) -> bool

Is the split hidden?

pub fn hide_split(&mut self, n: usize) -> bool

Hide the split and adds its area to the following split. If there is no following split it will go left/up. Leaves enough space to render the splitter.

pub fn show_split(&mut self, n: usize) -> bool

Show a hidden split. It will first try to reduce the areas to the right, and then the areas to the left to make space.

Trait Implementations

impl Clone for SplitState

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SplitState

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

Formats the value using the given formatter.

impl Default for SplitState

fn default() -> Self

Returns the “default value” for a type.

impl HandleEvent<Event, MouseOnly, Outcome> for SplitState

fn handle(&mut self, event: &Event, _qualifier: MouseOnly) -> Outcome

Handle an event.

impl HandleEvent<Event, Regular, Outcome> for SplitState

fn handle(&mut self, event: &Event, _qualifier: Regular) -> Outcome

Handle an event.

impl HasFocus for SplitState

fn build(&self, builder: &mut FocusBuilder)

Build the focus-structure for the container.

fn focus(&self) -> FocusFlag

Access to the flag for the rest.

fn area(&self) -> Rect

Area for mouse focus.

fn navigable(&self) -> Navigation

Declares how the widget interacts with focus.

fn id(&self) -> usize

Provide a unique id for the widget.

fn area_z(&self) -> u16

Z value for the area.

fn is_focused(&self) -> bool

Focused?

fn lost_focus(&self) -> bool

Just lost focus.

fn gained_focus(&self) -> bool

Just gained focus.

impl RelocatableState for SplitState

fn relocate(&mut self, shift: (i16, i16), clip: Rect)

Relocate the areas in this widgets state.

fn relocate_popup(&mut self, shift: (i16, i16), clip: Rect)

Relocate only popup areas. As rendering the popups is a separate render, this has to be separate too.

fn relocate_popup_hidden(&mut self)

Relocate all popup areas to a clip-rect (0,0+0x0).

fn relocate_hidden(&mut self)

Relocate all areas to a clip-rect (0,0+0x0).