Struct rerun::external::re_ui::ListItem

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

Generic widget for use in lists.

Layout:

┌───┬────────────────────────────────────────────────────────────┬───┐
│   │┌──────┐ ┌──────┐                           ┌──────┐┌──────┐│   │
│   ││  __  │ │      │                           │      ││      ││   │
│   ││  \/  │ │ icon │  label                    │ btns ││ btns ││   │
│   ││      │ │      │                           │      ││      ││   │
│   │└──────┘ └──────┘                           └──────┘└──────┘│   │
└───┴────────────────────────────────────────────────────────────┴───┘
    ◀───────────── allocated width (used for layout) ───────────▶
◀────────────── clip rectangle (used for highlighting) ─────────────▶

Features:

• selectable
• full span highlighting based on clip rectangle
• optional icon
• optional on-hover buttons on the right
• optional collapsing behavior for trees

This widget relies on the clip rectangle to be properly set as it use it for the shape if its background highlighting. This has a significant impact on the hierarchy of the UI. This is typically how things should be laid out:

Panel (no margin, set the clip rectangle)
└── ScrollArea (no margin)
    └── Frame (with inner margin)
        └── ListItem

See ReUi::panel_content for an helper to build the egui::Frame with proper margins.

Implementations

impl<'a> ListItem<'a>

pub fn new(re_ui: &'a ReUi, text: impl Into<WidgetText>) -> ListItem<'a>

Create a new ListItem with the given label.

pub fn interactive(self, interactive: bool) -> ListItem<'a>

Can the user click and interact with it?

Set to false for items that only show info, but shouldn’t be interactive.

pub fn selected(self, selected: bool) -> ListItem<'a>

Set the selected state of the item.

pub fn draggable(self, draggable: bool) -> ListItem<'a>

Make the item draggable.

pub fn drop_target_style(self, drag_target: bool) -> ListItem<'a>

Highlight the item as the current drop target.

Use this while dragging, to highlight which container will receive the drop at any given time. Note: this flag has otherwise no behavioural effect. It’s up to the caller to set it when the item is being hovered (or otherwise selected as drop target) while a drag is in progress.

pub fn subdued(self, subdued: bool) -> ListItem<'a>

Set the subdued state of the item.

Note: takes precedence over Self::weak if set.

pub fn weak(self, weak: bool) -> ListItem<'a>

Set the weak state of the item.

Note: Self::subdued takes precedence if set.

pub fn italics(self, italics: bool) -> ListItem<'a>

Render text in italic.

pub fn label_style(self, style: LabelStyle) -> ListItem<'a>

Style the label for an unnamed items.

The styling is applied on top of to Self::weak and Self::subdued. It also implies Self::italics.

pub fn force_hovered(self, force_hovered: bool) -> ListItem<'a>

Override the hovered state even if the item is not actually hovered.

Used to highlight items representing things that are hovered elsewhere in the UI. Note that the egui::Response returned by Self::show_flat, Self::show_hierarchical, and Self::show_hierarchical_with_content will still reflect the actual hover state.

pub fn with_height(self, height: f32) -> ListItem<'a>

Set the item height.

The default is provided by ReUi::list_item_height and is suitable for hierarchical lists.

pub fn width_allocation_mode(self, mode: WidthAllocationMode) -> ListItem<'a>

Set the width allocation mode.

pub fn with_icon(self, icon: &'a Icon) -> ListItem<'a>

Provide an Icon to be displayed on the left of the item.

pub fn with_icon_fn( self, icon_fn: impl FnOnce(&ReUi, &Ui, Rect, WidgetVisuals) + 'a ) -> ListItem<'a>

Provide a custom closure to draw an icon on the left of the item.

pub fn with_buttons( self, buttons: impl FnOnce(&ReUi, &mut Ui) -> Response + 'a ) -> ListItem<'a>

Provide a closure to display on-hover buttons on the right of the item.

Buttons also show when the item is selected, in order to support clicking them on touch screens.

Notes:

• If buttons are used, the item will allocate the full available width of the parent. If the enclosing UI adapts to the childrens width, it will unnecessarily grow. If buttons aren’t used, the item will only allocate the width needed for the text and icons if any.
• A right to left layout is used, so the right-most button must be added first.

pub fn show_flat(self, ui: &mut Ui) -> Response

Draw the item as part of a flat list.

pub fn show_hierarchical(self, ui: &mut Ui) -> Response

Draw the item as a leaf node from a hierarchical list.

pub fn show_hierarchical_with_content<R>( self, ui: &mut Ui, id: impl Into<Id>, default_open: bool, add_body: impl FnOnce(&ReUi, &mut Ui) -> R ) -> ShowCollapsingResponse<R>

Draw the item as a non-leaf node from a hierarchical list.