chore: improve bone id widget; now it is an autocomplete-style text input

Author: mbrea-c

crates/bevy_animation_graph_editor/src/ui/editor_windows/ragdoll_editor/body_mapping_inspector.rs

@@ -1,7 +1,7 @@
 use bevy_animation_graph::core::{ragdoll::bone_mapping::BodyMapping, skeleton::Skeleton};
 use egui::Widget;
 
-use crate::ui::generic_widgets::{bone_id::BoneIdWidget, isometry3d::Isometry3dWidget};
+use crate::ui::generic_widgets::{bone_id_via_path::BoneIdWidget, isometry3d::Isometry3dWidget};
 
 pub struct BodyMappingInspector<'a> {
     pub body_mapping: &'a mut BodyMapping,
@@ -20,10 +20,8 @@ impl Widget for BodyMappingInspector<'_> {
 
                 response |= ui.label("target bone:");
                 let mut bone_id = bone.bone.id();
-                response |= ui.add(
-                    BoneIdWidget::new_salted(&mut bone_id, "bone id picker")
-                        .with_skeleton(Some(self.skeleton)),
-                );
+                response |=
+                    ui.add(BoneIdWidget::new(&mut bone_id, self.skeleton).salted("bone id picker"));
                 if let Some(path) = self.skeleton.id_to_path(bone_id) {
                     bone.bone = path;
                 }

crates/bevy_animation_graph_editor/src/ui/generic_widgets/bone_id_via_path.rs

@@ -0,0 +1,78 @@
+use bevy_animation_graph::core::{animation_clip::EntityPath, id::BoneId, skeleton::Skeleton};
+
+use crate::ui::generic_widgets::entity_path::EntityPathWidget;
+
+pub struct BoneIdWidget<'a> {
+    pub bone_id: &'a mut BoneId,
+    pub id_hash: egui::Id,
+    pub skeleton: &'a Skeleton,
+}
+
+impl<'a> BoneIdWidget<'a> {
+    pub fn new(bone_id: &'a mut BoneId, skeleton: &'a Skeleton) -> Self {
+        Self {
+            bone_id,
+            id_hash: egui::Id::new("bone id widget"),
+            skeleton,
+        }
+    }
+
+    pub fn salted(mut self, salt: impl std::hash::Hash) -> Self {
+        self.id_hash = egui::Id::new(salt);
+        self
+    }
+}
+
+impl<'a> egui::Widget for BoneIdWidget<'a> {
+    fn ui(self, ui: &mut egui::Ui) -> egui::Response {
+        ui.push_id(self.id_hash, |ui| {
+            let current_path = self.skeleton.id_to_path(*self.bone_id).unwrap_or_default();
+            let mut buffer = Buffer::from_ui(ui, *self.bone_id, current_path);
+
+            let response = ui.add(
+                EntityPathWidget::new_salted(&mut buffer.path, "bone id entity path")
+                    .with_options(self.skeleton.iter_paths()),
+            );
+            buffer.write_back(ui);
+
+            if response.changed() {
+                *self.bone_id = buffer.path.id();
+            }
+
+            response
+        })
+        .inner
+    }
+}
+
+#[derive(Clone)]
+pub struct Buffer {
+    original_id: BoneId,
+    path: EntityPath,
+}
+
+impl Buffer {
+    pub fn from_ui(ui: &mut egui::Ui, bone_id: BoneId, path: EntityPath) -> Self {
+        let id = Self::id(ui);
+        ui.memory_mut(|mem| {
+            let new = move || Self {
+                original_id: bone_id,
+                path: path.clone(),
+            };
+            let val = mem.data.get_temp_mut_or_insert_with(id, &new).clone();
+            if val.original_id == bone_id {
+                val
+            } else {
+                new()
+            }
+        })
+    }
+    pub fn write_back(&self, ui: &mut egui::Ui) {
+        let id = Self::id(ui);
+        ui.memory_mut(|mem| mem.data.insert_temp(id, self.clone()));
+    }
+
+    fn id(ui: &egui::Ui) -> egui::Id {
+        ui.id().with("bone id buffer")
+    }
+}

crates/bevy_animation_graph_editor/src/ui/generic_widgets/entity_path.rs

@@ -46,35 +46,53 @@ impl<'a> egui::Widget for EntityPathWidget<'a> {
                     .clone()
             });
 
-            let response = ui.add(
+            let text_edit_response = ui.add(
                 egui::TextEdit::singleline(&mut buffer.value).min_size(egui::Vec2::new(350., 0.)),
             );
 
+            let mut final_response = text_edit_response.clone();
+
             let top_k = self
                 .options
                 .iter()
                 .filter(|opt| opt.to_slashed_string().starts_with(&buffer.value))
                 .take(10)
                 .collect::<Vec<_>>();
 
-            if !top_k.is_empty() && response.has_focus() {
-                response.show_tooltip_ui(|ui| {
+            egui::Popup::menu(&text_edit_response)
+                .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
+                .open_memory(
+                    (!top_k.is_empty() && text_edit_response.has_focus())
+                        .then_some(egui::SetOpenCommand::Bool(true)),
+                )
+                .show(|ui| {
                     for opt in top_k {
                         let slashed = opt.to_slashed_string();
                         let Some(rest) = slashed.strip_prefix(&buffer.value) else {
                             continue;
                         };
 
-                        ui.horizontal(|ui| {
-                            ui.spacing_mut().item_spacing = egui::Vec2::ZERO;
-                            ui.label(egui::RichText::new(&buffer.value).strong());
-                            ui.label(egui::RichText::new(rest));
-                        });
+                        let r = ui
+                            .horizontal(|ui| {
+                                ui.spacing_mut().item_spacing = egui::Vec2::ZERO;
+                                let r = ui.add(
+                                    egui::Button::new((
+                                        egui::RichText::new(&buffer.value).strong(),
+                                        egui::RichText::new(rest),
+                                    ))
+                                    .frame(false),
+                                );
+                                r
+                            })
+                            .inner;
+                        if r.clicked() {
+                            *self.entity_path = (*opt).clone();
+                            final_response.mark_changed();
+                        }
                     }
                 });
-            }
 
-            if response.changed()
+            if text_edit_response.changed()
                 && let Some(new_path) =
                     EntityPath::from_slashed_string_if_safe(buffer.value.clone())
             {
@@ -83,7 +101,7 @@ impl<'a> egui::Widget for EntityPathWidget<'a> {
 
             ui.memory_mut(|mem| mem.data.insert_temp(buffer_id, buffer));
 
-            response
+            final_response
         })
         .inner
     }

crates/bevy_animation_graph_editor/src/ui/generic_widgets/mod.rs

@@ -4,6 +4,7 @@ pub mod asset_picker;
 pub mod body_id;
 pub mod body_mode;
 pub mod bone_id;
+pub mod bone_id_via_path;
 pub mod bone_mask;
 pub mod data_spec_widget;
 pub mod data_value;