egui_dnd 0.15.0

A drag and drop library for 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

use eframe::egui;
use eframe::egui::{CollapsingHeader, Id, Ui};

use egui_dnd::{dnd, DragDropItem, Handle};

pub fn main() -> eframe::Result<()> {
    let options = eframe::NativeOptions {
        ..Default::default()
    };
    eframe::run_native("DnD", options, Box::new(|_cc| Ok(Box::<MyApp>::default())))
}

#[derive(Default)]
struct SortableItem {
    name: String,

    children: Option<Vec<SortableItem>>,
}

impl DragDropItem for &mut SortableItem {
    fn id(&self) -> Id {
        Id::new(&self.name)
    }
}

struct MyApp {
    items: Vec<SortableItem>,
}

impl Default for MyApp {
    fn default() -> Self {
        MyApp {
            items: vec![
                SortableItem {
                    name: "a".to_string(),
                    ..SortableItem::default()
                },
                SortableItem {
                    name: "b".to_string(),
                    ..SortableItem::default()
                },
                SortableItem {
                    name: "c".to_string(),
                    ..SortableItem::default()
                },
                SortableItem {
                    name: "d".to_string(),
                    ..SortableItem::default()
                },
                SortableItem {
                    name: "e".to_string(),
                    children: Some(vec![
                        SortableItem {
                            name: "e_a".to_string(),
                            ..SortableItem::default()
                        },
                        SortableItem {
                            name: "e_b".to_string(),
                            ..SortableItem::default()
                        },
                        SortableItem {
                            name: "e_c".to_string(),
                            ..SortableItem::default()
                        },
                        SortableItem {
                            name: "e_d".to_string(),
                            ..SortableItem::default()
                        },
                    ]),
                },
            ],
        }
    }
}

impl MyApp {
    fn draw_item(ui: &mut Ui, item: &mut SortableItem, handle: Handle) {
        handle.ui(ui, |ui| {
            ui.label(&item.name);
        });

        if let Some(children) = &mut item.children {
            CollapsingHeader::new("children")
                .default_open(true)
                .show(ui, |ui| {
                    ui.label("Content");

                    let response = dnd(ui, &item.name).show(
                        children.iter_mut(),
                        |ui, item, handle, _pressed| {
                            Self::draw_item(ui, item, handle);
                        },
                    );

                    response.update_vec(children);
                });
        }
    }
}

impl eframe::App for MyApp {
    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show_inside(ui, |ui| {
            let response =
                dnd(ui, "dnd_example").show(self.items.iter_mut(), |ui, item, handle, _pressed| {
                    MyApp::draw_item(ui, item, handle);
                });
            response.update_vec(&mut self.items);
        });
    }
}