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

use std::collections::HashMap;
use std::hash::Hash;

use bevy::prelude::App;

use crate::{egui, Context};
use crate::{utils, Inspectable};

impl<K, V> Inspectable for HashMap<K, V>
where
    K: Inspectable + Clone + Eq + Hash + Default,
    V: Inspectable + Default,
{
    type Attributes = (
        <K as Inspectable>::Attributes,
        <V as Inspectable>::Attributes,
    );

    fn ui(&mut self, ui: &mut egui::Ui, options: Self::Attributes, context: &mut Context) -> bool {
        let mut changed = false;

        ui.vertical(|ui| {
            let mut to_delete = None;
            let mut to_update = Vec::new();

            let len = self.len();
            for (i, (key, val)) in self.iter_mut().enumerate() {
                ui.horizontal(|ui| {
                    if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                        to_delete = Some(key.clone());
                    }

                    let mut k = key.clone();
                    if k.ui(ui, options.0.clone(), &mut context.with_id(i as u64)) {
                        to_update.push((key.clone(), k));
                    }

                    changed |= val.ui(ui, options.1.clone(), &mut context.with_id(i as u64));
                });

                if i != len - 1 {
                    ui.separator();
                }
            }

            ui.vertical_centered_justified(|ui| {
                if ui.button("+").clicked() {
                    self.insert(K::default(), V::default());
                    changed = true;
                }
            });

            for (old_key, new_key) in to_update.drain(..) {
                if let Some(val) = self.remove(&old_key) {
                    self.insert(new_key, val);
                    changed = true;
                }
            }

            if let Some(key) = to_delete {
                if self.remove(&key).is_some() {
                    changed = true;
                }
            }
        });

        changed
    }

    fn setup(app: &mut App) {
        K::setup(app);
        V::setup(app);
    }
}