Struct DisplayedItemTree

pub struct DisplayedItemTree {
    items: Vec<Node>,
}

Tree if items to be displayed

Items are stored in a flat list, with the level property indicating the nesting level of the item. The items are stored in-order. For documentation on the properties of a node, see the Node struct.

Note also infos on the VisibleItemIndex and ItemIndex types w.r.t. stability of these index types.

Invariants:

• The nesting levels of the tree must monotonically increase (but may jump levels going down)

Fields

items: Vec<Node>

Implementations

impl DisplayedItemTree

pub fn new() -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = &Node> + use<'_>

pub fn iter_visible(&self) -> VisibleItemIterator<'_>

Iterate through all visible items

pub fn iter_visible_mut(&mut self) -> VisibleItemIteratorMut<'_>

pub fn iter_visible_extra(&self) -> VisibleItemIteratorExtraInfo<'_>

pub fn iter_visible_selected(&self) -> impl Iterator<Item = &Node> + use<'_>

pub fn get_visible(&self, index: VisibleItemIndex) -> Option<&Node>

Iterate through items, skipping invisible items, return index of n-th visible item

pub fn get_visible_extra(&self, index: VisibleItemIndex) -> Option<Info<'_>>

pub fn get(&self, index: ItemIndex) -> Option<&Node>

pub fn get_mut(&mut self, index: ItemIndex) -> Option<&mut Node>

pub fn to_displayed(&self, index: VisibleItemIndex) -> Option<ItemIndex>

pub fn insert_item( &mut self, item: DisplayedItemRef, position: TargetPosition, ) -> Result<ItemIndex, MoveError>

insert item after offset visible items (either in root or in unfolded parent)

pub fn subtree_end(&self, start_idx: usize) -> usize

Return the index past the end of the subtree started by idx

pub fn remove_recursive( &mut self, ItemIndex: ItemIndex, ) -> Vec<DisplayedItemRef>

pub fn remove_dissolve(&mut self, ItemIndex: ItemIndex) -> DisplayedItemRef

pub fn drain_recursive_if<F>(&mut self, f: F) -> Vec<DisplayedItemRef>

where F: Fn(&Node) -> bool,

fn visible_predecessor(&self, idx: usize) -> Option<usize>

Find the item before idx that is visible, independent of level

pub fn move_item<F>( &mut self, vidx: VisibleItemIndex, direction: MoveDir, f: F, ) -> Result<VisibleItemIndex, MoveError>

where F: Fn(&Node) -> bool,

Move a visible item (and it’s subtree) up/down by one visible item

When moving up we move into all visible deeper trees first before skipping up. Moving down we move out until we are on the level of the next element. This way all indentations possible due to opened subtrees are reachable.

Folded subtrees are skipped.

f will be called with a node that might become the parent after move. It must return true iff that node is allowed to have child nodes.

pub fn move_items( &mut self, indices: Vec<ItemIndex>, target: TargetPosition, ) -> Result<(), MoveError>

Move multiple items to a specified location

Indices may be unsorted and contain duplicates, but must be valid. Visibility is ignored for this function.

Deals with any combination of items to move, except the error cases below. Rules that are followed:

• The relative order of element should be the same, before and after the move
• If the root of a subtree is moved, the whole subtree is moved
• If a node inside a subtree is moved, then it’s moved out of that subtree
• If both the root and a node of a subtree are moved, the node is moved out of the subtree and ends up after the root node

Possible errors:

• trying to move an element into itself
• trying to move an element into another moved element
• invalid indices
• level too deep for subtree, level is clipped to level 255

pub fn valid_levels_visible<F>(&self, item: VisibleItemIndex, f: F) -> Range<u8>

where F: Fn(&Node) -> bool,

Return the range of valid levels for inserting above item, given the visible nodes

f will be called with what will become the in-order predecessor node after insert. It must return true iff that node is allowed to have child nodes.

pub fn xfold(&mut self, ItemIndex: ItemIndex, unfolded: bool)

pub fn xfold_all(&mut self, unfolded: bool)

pub fn xfold_recursive(&mut self, ItemIndex: ItemIndex, unfolded: bool)

pub fn xselect(&mut self, vidx: VisibleItemIndex, selected: bool)

pub fn xselect_all_visible(&mut self, selected: bool)

Select/Deselect all visible items

pub fn xselect_visible_range( &mut self, VisibleItemIndex: VisibleItemIndex, VisibleItemIndex: VisibleItemIndex, selected: bool, )

Change selection for visible items, in inclusive range

pub fn subtree_contains( &self, ItemIndex: ItemIndex, ItemIndex: ItemIndex, ) -> bool

Trait Implementations

impl Clone for DisplayedItemTree

fn clone(&self) -> DisplayedItemTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DisplayedItemTree

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

Formats the value using the given formatter.

impl Default for DisplayedItemTree

fn default() -> DisplayedItemTree

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DisplayedItemTree

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DisplayedItemTree

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.