Plot items now require an id (#82)

Author: Wumpf

demo/src/plot_demo.rs

@@ -51,7 +51,7 @@ pub struct Legend {
     color_conflict_handling: ColorConflictHandling,
 
     /// Used for overriding the `hidden_items` set in [`LegendWidget`].
-    hidden_items: Option<ahash::HashSet<String>>,
+    hidden_items: Option<ahash::HashSet<Id>>,
 }
 
 impl Default for Legend {
@@ -94,7 +94,7 @@ impl Legend {
     #[inline]
     pub fn hidden_items<I>(mut self, hidden_items: I) -> Self
     where
-        I: IntoIterator<Item = String>,
+        I: IntoIterator<Item = Id>,
     {
         self.hidden_items = Some(hidden_items.into_iter().collect());
         self
@@ -123,33 +123,36 @@ impl Legend {
 
 #[derive(Clone)]
 struct LegendEntry {
-    item_id: Option<Id>,
+    id: Id,
+    name: String,
     color: Color32,
     checked: bool,
     hovered: bool,
 }
 
 impl LegendEntry {
-    fn new(item_id: Option<Id>, color: Color32, checked: bool) -> Self {
+    fn new(id: Id, name: String, color: Color32, checked: bool) -> Self {
         Self {
-            item_id,
+            id,
+            name,
             color,
             checked,
             hovered: false,
         }
     }
 
-    fn ui(&self, ui: &mut Ui, text: String, text_style: &TextStyle) -> Response {
+    fn ui(&self, ui: &mut Ui, text_style: &TextStyle) -> Response {
         let Self {
-            item_id: _,
+            id: _,
+            name,
             color,
             checked,
             hovered: _,
         } = self;
 
         let font_id = text_style.resolve(ui.style());
 
-        let galley = ui.fonts(|f| f.layout_delayed_color(text, font_id, f32::INFINITY));
+        let galley = ui.fonts(|f| f.layout_delayed_color(name.clone(), font_id, f32::INFINITY));
 
         let icon_size = galley.size().y;
         let icon_spacing = icon_size / 5.0;
@@ -216,36 +219,26 @@ impl LegendEntry {
 #[derive(Clone)]
 pub(super) struct LegendWidget {
     rect: Rect,
-    entries: Vec<(String, LegendEntry)>,
+    entries: Vec<LegendEntry>,
     config: Legend,
 }
 
-/// A reference to a legend item.
-///
-/// Since item ids are optional, we need to keep the name as well, using it for identification if needed.
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct LegendItemReference {
-    pub name: String,
-    pub item_id: Option<Id>,
-}
-
 impl LegendWidget {
     /// Create a new legend from items, the names of items that are hidden and the style of the
     /// text. Returns `None` if the legend has no entries.
     pub(super) fn try_new<'a>(
         rect: Rect,
         config: Legend,
         items: &[Box<dyn PlotItem + 'a>],
-        hidden_items: &ahash::HashSet<String>, // Existing hidden items in the plot memory.
+        hidden_items: &ahash::HashSet<Id>, // Existing hidden items in the plot memory.
     ) -> Option<Self> {
         // If `config.hidden_items` is not `None`, it is used.
         let hidden_items = config.hidden_items.as_ref().unwrap_or(hidden_items);
 
         // Collect the legend entries. If multiple items have the same name, they share a
         // checkbox. If their colors don't match, we pick a neutral color for the checkbox.
         let mut keys: BTreeMap<String, usize> = BTreeMap::new();
-        let mut entries: BTreeMap<(usize, String), LegendEntry> = BTreeMap::new();
+        let mut entries: BTreeMap<(usize, &str), LegendEntry> = BTreeMap::new();
         items
             .iter()
             .filter(|item| !item.name().is_empty())
@@ -257,8 +250,9 @@ impl LegendWidget {
                     // Use the same key if we don't want insertion order
                     0
                 };
+
                 entries
-                    .entry((key, item.name().to_owned()))
+                    .entry((key, item.name()))
                     .and_modify(|entry| {
                         if entry.color != item.color() {
                             match config.color_conflict_handling {
@@ -273,35 +267,30 @@ impl LegendWidget {
                     })
                     .or_insert_with(|| {
                         let color = item.color();
-                        let checked = !hidden_items.contains(item.name());
-                        LegendEntry::new(item.id(), color, checked)
+                        let checked = !hidden_items.contains(&item.id());
+                        LegendEntry::new(item.id(), item.name().to_owned(), color, checked)
                     });
             });
         (!entries.is_empty()).then_some(Self {
             rect,
-            entries: entries.into_iter().map(|((_, k), v)| (k, v)).collect(),
+            entries: entries.into_values().collect(),
             config,
         })
     }
 
     // Get the names of the hidden items.
-    pub fn hidden_items(&self) -> ahash::HashSet<String> {
+    pub fn hidden_items(&self) -> ahash::HashSet<Id> {
         self.entries
             .iter()
-            .filter(|(_, entry)| !entry.checked)
-            .map(|(name, _)| name.clone())
+            .filter_map(|entry| (!entry.checked).then_some(entry.id))
             .collect()
     }
 
     // Get the name of the hovered items.
-    pub fn hovered_item(&self) -> Option<LegendItemReference> {
+    pub fn hovered_item(&self) -> Option<Id> {
         self.entries
             .iter()
-            .find(|(_, entry)| entry.hovered)
-            .map(|(name, entry)| LegendItemReference {
-                name: name.to_string(),
-                item_id: entry.item_id,
-            })
+            .find_map(|entry| entry.hovered.then_some(entry.id))
     }
 }
 
@@ -343,14 +332,14 @@ impl Widget for &mut LegendWidget {
 
                         let response_union = entries
                             .iter_mut()
-                            .map(|(name, entry)| {
-                                let response = entry.ui(ui, name.clone(), &config.text_style);
+                            .map(|entry| {
+                                let response = entry.ui(ui, &config.text_style);
 
                                 // Handle interactions. Alt-clicking must be deferred to end of loop
                                 // since it may affect all entries.
                                 handle_interaction_on_legend_item(&response, entry);
                                 if response.clicked() && ui.input(|r| r.modifiers.alt) {
-                                    focus_on_item = Some(name.clone());
+                                    focus_on_item = Some(entry.id);
                                 }
 
                                 response
@@ -377,14 +366,14 @@ fn handle_interaction_on_legend_item(response: &Response, entry: &mut LegendEntr
 }
 
 /// Handle alt-click interaction (which may affect all entries).
-fn handle_focus_on_legend_item(clicked_entry_name: &str, entries: &mut [(String, LegendEntry)]) {
+fn handle_focus_on_legend_item(clicked_entry: &Id, entries: &mut [LegendEntry]) {
     // if all other items are already hidden, we show everything
     let is_focus_item_only_visible = entries
         .iter()
-        .all(|(name, entry)| !entry.checked || (clicked_entry_name == name));
+        .all(|entry| !entry.checked || (clicked_entry == &entry.id));
 
     // either show everything or show only the focus item
-    for (name, entry) in entries.iter_mut() {
-        entry.checked = is_focus_item_only_visible || clicked_entry_name == name;
+    for entry in entries.iter_mut() {
+        entry.checked = is_focus_item_only_visible || clicked_entry == &entry.id;
     }
 }

egui_plot/src/items/mod.rs

@@ -39,7 +39,7 @@ pub use crate::{
 
 use axis::AxisWidget;
 use items::{horizontal_line, rulers_color, vertical_line};
-use legend::{LegendItemReference, LegendWidget};
+use legend::LegendWidget;
 
 type LabelFormatterFn<'a> = dyn Fn(&str, &PlotPoint) -> String + 'a;
 pub type LabelFormatter<'a> = Option<Box<LabelFormatterFn<'a>>>;
@@ -125,7 +125,7 @@ pub struct PlotResponse<R> {
 
     /// The id of a currently hovered item if any.
     ///
-    /// This is `None` if either no item was hovered, or the hovered item didn't provide an id.
+    /// This is `None` if either no item was hovered.
     /// A plot item can be hovered either by hovering its representation in the plot (line, marker, etc.)
     /// or by hovering the item in the legend.
     pub hovered_plot_item: Option<Id>,
@@ -145,7 +145,7 @@ pub struct PlotResponse<R> {
 ///     let x = i as f64 * 0.01;
 ///     [x, x.sin()]
 /// }).collect();
-/// let line = Line::new(sin);
+/// let line = Line::new("sin", sin);
 /// Plot::new("my_plot").view_aspect(2.0).show(ui, |plot_ui| plot_ui.line(line));
 /// # });
 /// ```
@@ -397,7 +397,7 @@ impl<'a> Plot<'a> {
     ///     let x = i as f64 * 0.01;
     ///     [x, x.sin()]
     /// }).collect();
-    /// let line = Line::new(sin);
+    /// let line = Line::new("sin", sin);
     /// Plot::new("my_plot").view_aspect(2.0)
     /// .label_formatter(|name, value| {
     ///     if !name.is_empty() {
@@ -898,21 +898,13 @@ impl<'a> Plot<'a> {
             show_y = false;
         }
         // Remove the deselected items.
-        items.retain(|item| !mem.hidden_items.contains(item.name()));
+        items.retain(|item| !mem.hidden_items.contains(&item.id()));
         // Highlight the hovered items.
-        if let Some(LegendItemReference { name, item_id }) = &mem.hovered_legend_item {
-            // If available, identify by id, not name.
-            if let Some(item_id) = item_id {
-                items
-                    .iter_mut()
-                    .filter(|entry| entry.id() == Some(*item_id))
-                    .for_each(|entry| entry.highlight());
-            } else {
-                items
-                    .iter_mut()
-                    .filter(|entry| entry.name() == name)
-                    .for_each(|entry| entry.highlight());
-            }
+        if let Some(item_id) = &mem.hovered_legend_item {
+            items
+                .iter_mut()
+                .filter(|entry| &entry.id() == item_id)
+                .for_each(|entry| entry.highlight());
         }
         // Move highlighted items to front.
         items.sort_by_key(|item| item.highlighted());
@@ -1224,11 +1216,7 @@ impl<'a> Plot<'a> {
             mem.hidden_items = legend.hidden_items();
             mem.hovered_legend_item = legend.hovered_item();
 
-            if let Some(LegendItemReference {
-                name: _,
-                item_id: Some(item_id),
-            }) = &mem.hovered_legend_item
-            {
+            if let Some(item_id) = &mem.hovered_legend_item {
                 hovered_plot_item.get_or_insert(*item_id);
             }
         }
@@ -1728,7 +1716,7 @@ impl<'a> PreparedPlot<'a> {
 
         let hovered_plot_item_id = if let Some((item, elem)) = closest {
             item.on_hover(elem, shapes, &mut cursors, &plot, label_formatter);
-            item.id()
+            Some(item.id())
         } else {
             let value = transform.value_from_position(pointer);
             items::rulers_at_value(

egui_plot/src/legend.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use egui::{Context, Id, Pos2, Vec2b};
 
-use crate::{legend::LegendItemReference, PlotBounds, PlotTransform};
+use crate::{PlotBounds, PlotTransform};
 
 /// Information about the plot that has to persist between frames.
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
@@ -15,12 +15,10 @@ pub struct PlotMemory {
     pub auto_bounds: Vec2b,
 
     /// Hovered legend item if any.
-    ///
-    /// Display string plus, if available, the id of the hovered item.
-    pub hovered_legend_item: Option<LegendItemReference>,
+    pub hovered_legend_item: Option<Id>,
 
     /// Which items _not_ to show?
-    pub hidden_items: ahash::HashSet<String>,
+    pub hidden_items: ahash::HashSet<Id>,
 
     /// The transform from last frame.
     pub(crate) transform: PlotTransform,

egui_plot/src/lib.rs

@@ -33,7 +33,8 @@ impl eframe::App for MyApp {
             Plot::new("My Plot")
                 .legend(Legend::default())
                 .show(ui, |plot_ui| {
-                    plot_ui.line(Line::new(PlotPoints::Borrowed(&self.points)).name("curve"));
+                    plot_ui
+                        .line(Line::new("curve", PlotPoints::Borrowed(&self.points)).name("curve"));
                 });
         });
     }

egui_plot/src/memory.rs

@@ -122,7 +122,7 @@ impl eframe::App for PlotExample {
                     }
 
                     let sine_points = PlotPoints::from_explicit_callback(|x| x.sin(), .., 5000);
-                    plot_ui.line(Line::new(sine_points).name("Sine"));
+                    plot_ui.line(Line::new("Sine", sine_points));
                 });
         });
     }

examples/borrow_points/src/main.rs

@@ -46,11 +46,15 @@ impl eframe::App for MyApp {
             Plot::new("My Plot")
                 .legend(Legend::default().follow_insertion_order(self.insert_order))
                 .show(ui, |plot_ui| {
-                    plot_ui
-                        .line(Line::new(PlotPoints::from(self.graph3.clone())).name("3rd Curve"));
-                    plot_ui.line(Line::new(PlotPoints::from(self.graph.clone())).name("1st Curve"));
-                    plot_ui
-                        .line(Line::new(PlotPoints::from(self.graph2.clone())).name("2nd Curve"));
+                    plot_ui.line(Line::new(
+                        "3rd Curve",
+                        PlotPoints::from(self.graph3.clone()),
+                    ));
+                    plot_ui.line(Line::new("1st Curve", PlotPoints::from(self.graph.clone())));
+                    plot_ui.line(Line::new(
+                        "2nd Curve",
+                        PlotPoints::from(self.graph2.clone()),
+                    ));
                 });
             // Remember the position of the plot
         });

examples/custom_plot_manipulation/src/main.rs

@@ -34,7 +34,7 @@ impl eframe::App for MyApp {
             // let's create a dummy line in the plot
             let graph: Vec<[f64; 2]> = vec![[0.0, 1.0], [2.0, 3.0], [3.0, 2.0]];
             let inner = my_plot.show(ui, |plot_ui| {
-                plot_ui.line(Line::new(PlotPoints::from(graph)).name("curve"));
+                plot_ui.line(Line::new("curve", PlotPoints::from(graph)));
             });
             // Remember the position of the plot
             plot_rect = Some(inner.response.rect);