nightshade 0.8.0

A cross-platform data-oriented game engine.
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 std::path::PathBuf;

use serde::{Deserialize, Serialize};

#[derive(Clone, Default, Serialize, Deserialize)]
pub struct RecentFiles {
    paths: Vec<PathBuf>,
    max_entries: usize,
}

pub enum RecentFilesAction {
    Open(PathBuf),
    Clear,
}

impl RecentFiles {
    pub fn new(max_entries: usize) -> Self {
        Self {
            paths: Vec::new(),
            max_entries,
        }
    }

    pub fn add(&mut self, path: PathBuf) {
        self.paths.retain(|existing| existing != &path);
        self.paths.insert(0, path);
        self.paths.truncate(self.max_entries);
    }

    pub fn remove(&mut self, path: &PathBuf) {
        self.paths.retain(|existing| existing != path);
    }

    pub fn clear(&mut self) {
        self.paths.clear();
    }

    pub fn paths(&self) -> &[PathBuf] {
        &self.paths
    }

    pub fn is_empty(&self) -> bool {
        self.paths.is_empty()
    }

    pub fn len(&self) -> usize {
        self.paths.len()
    }

    pub fn render_menu(
        &self,
        ui: &mut egui::Ui,
        pinned_path: Option<&str>,
        display_name_fn: impl Fn(&std::path::Path) -> String,
    ) -> Option<RecentFilesAction> {
        let mut action = None;

        ui.label(
            egui::RichText::new("Recent Projects")
                .color(egui::Color32::from_rgb(150, 150, 150))
                .small()
                .strong(),
        );
        ui.add_space(4.0);

        if self.paths.is_empty() {
            ui.label(
                egui::RichText::new("  No recent projects")
                    .color(egui::Color32::from_rgb(120, 120, 120))
                    .small()
                    .italics(),
            );
        } else {
            for path in &self.paths {
                let path_string = path.to_string_lossy().to_string();
                let project_name = display_name_fn(path);
                let is_pinned = pinned_path.is_some_and(|pinned| path_string == pinned);
                let display_name = if project_name.trim().is_empty() {
                    if is_pinned {
                        "⭐ Untitled".to_string()
                    } else {
                        "Untitled".to_string()
                    }
                } else if is_pinned {
                    format!("⭐ {}", project_name)
                } else {
                    project_name
                };

                let button = ui
                    .add(
                        egui::Button::new(
                            egui::RichText::new(display_name)
                                .color(egui::Color32::from_rgb(100, 200, 255)),
                        )
                        .min_size(egui::vec2(200.0, 0.0)),
                    )
                    .on_hover_text(&path_string);

                if button.clicked() {
                    action = Some(RecentFilesAction::Open(path.clone()));
                    ui.close();
                }
            }

            ui.add_space(4.0);
            if ui
                .button(
                    egui::RichText::new("Clear Recent Projects")
                        .color(egui::Color32::from_rgb(255, 100, 100))
                        .small(),
                )
                .clicked()
            {
                action = Some(RecentFilesAction::Clear);
                ui.close();
            }
        }

        action
    }
}