re_ui 0.31.3

Rerun GUI theme and helpers, built around egui
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::UiExt as _;
use crate::re_form::{ConstructFormStrip, FormStrip, Fractions, form_field_frame};
use egui::epaint::RectShape;
use egui::layers::ShapeIdx;
use egui::{
    AtomLayout, Atoms, Direction, Frame, IntoAtoms, Layout, Response, Shape, Stroke, StrokeKind,
    Ui, Widget,
};
use std::ops::{Deref, DerefMut};

pub struct SelectableStrip<'a> {
    strip: FormStrip<'a>,
    bg_idx: ShapeIdx,
}

impl<'a> SelectableStrip<'a> {
    pub fn single(ui: &'a mut Ui, widget: impl Widget) -> Response {
        let mut fields = Self::same(ui, 1);
        fields.add(widget)
    }

    pub fn selectable_value<Value: PartialEq>(
        mut self,
        current_value: &mut Value,
        selected_value: Value,
        atoms: impl IntoAtoms<'a>,
    ) -> Self {
        let toggle = SelectableToggle::new(atoms, *current_value == selected_value);
        let mut response = self.strip.add(toggle);
        if response.clicked() {
            *current_value = selected_value;
            response.mark_changed();
        }
        self
    }
}

impl<'a> ConstructFormStrip<'a> for SelectableStrip<'a> {
    fn new(ui: &'a mut Ui, fields: Fractions) -> Self {
        // FormStrip::new reads spacing during construction so we override it here
        let item_spacing = std::mem::take(&mut ui.spacing_mut().item_spacing);
        let strip = FormStrip::new(ui, fields)
            .with_item_layout(Layout::centered_and_justified(Direction::LeftToRight));
        strip.ui.spacing_mut().item_spacing = item_spacing;

        let bg_idx = strip.child_ui.painter().add(Shape::Noop);

        Self { strip, bg_idx }
    }
}

impl<'a> Deref for SelectableStrip<'a> {
    type Target = FormStrip<'a>;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.strip
    }
}

impl DerefMut for SelectableStrip<'_> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.strip
    }
}

impl Drop for SelectableStrip<'_> {
    fn drop(&mut self) {
        let rect = self.strip.child_ui.min_rect();
        let frame = form_field_frame(self.strip.child_ui.tokens());
        self.strip.child_ui.painter().set(
            self.bg_idx,
            Shape::Rect(RectShape::new(
                rect,
                frame.corner_radius,
                frame.fill,
                frame.stroke,
                StrokeKind::Inside,
            )),
        );
    }
}

pub struct SelectableToggle<'a> {
    atoms: Atoms<'a>,
    selected: bool,
}

impl<'a> SelectableToggle<'a> {
    pub fn new(atoms: impl IntoAtoms<'a>, selected: bool) -> Self {
        Self {
            atoms: atoms.into_atoms(),
            selected,
        }
    }
}

impl Widget for SelectableToggle<'_> {
    fn ui(self, ui: &mut Ui) -> Response {
        // Allocate widget space and observe interactions.
        let mut atom_layout = AtomLayout::new(self.atoms)
            .frame(Frame::new().corner_radius(4.0))
            .sense(egui::Sense::click())
            .allocate(ui);

        // Set selected style.
        if self.selected {
            atom_layout.frame = atom_layout
                .frame
                .stroke(Stroke::new(1.0, ui.tokens().form_selectable_stroke_color))
                .fill(ui.tokens().form_selectable_bg_color);
        }

        if atom_layout.response.hovered() {
            let hover_fill = ui.style().visuals.widgets.hovered.bg_fill;
            atom_layout.frame = atom_layout.frame.fill(hover_fill);
        }

        atom_layout.paint(ui).response
    }
}