eldiron-creator 0.9.7

A game creator for classical RPGs.
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

use crate::editor::{DOCKMANAGER, SIDEBARMODE};
use crate::prelude::*;
use crate::sidebar::SidebarMode;
use ToolEvent::*;

pub struct PaletteTool {
    id: TheId,
    previous_dock: Option<String>,
    previous_sidebar_mode: Option<SidebarMode>,
}

impl PaletteTool {
    fn selection_tool_type(project: &Project, server_ctx: &ServerContext) -> MapToolType {
        if let Some(map) = project.get_map(server_ctx) {
            if !map.selected_vertices.is_empty() {
                MapToolType::Vertex
            } else if !map.selected_linedefs.is_empty() {
                MapToolType::Linedef
            } else if !map.selected_sectors.is_empty() {
                MapToolType::Sector
            } else {
                MapToolType::Sector
            }
        } else {
            MapToolType::Sector
        }
    }
}

impl Tool for PaletteTool {
    fn new() -> Self
    where
        Self: Sized,
    {
        Self {
            id: TheId::named("Palette Tool"),
            previous_dock: None,
            previous_sidebar_mode: None,
        }
    }

    fn id(&self) -> TheId {
        self.id.clone()
    }

    fn info(&self) -> String {
        fl!("tool_palette")
    }

    fn icon_name(&self) -> String {
        "droplet".to_string()
    }

    fn accel(&self) -> Option<char> {
        Some('P')
    }

    fn help_url(&self) -> Option<String> {
        Some("docs/creator/tools/palette".to_string())
    }

    fn tool_event(
        &mut self,
        tool_event: ToolEvent,
        ui: &mut TheUI,
        ctx: &mut TheContext,
        project: &mut Project,
        server_ctx: &mut ServerContext,
    ) -> bool {
        match tool_event {
            Activate => {
                server_ctx.palette_tool_active = true;
                server_ctx.curr_map_tool_type = Self::selection_tool_type(project, server_ctx);
                server_ctx.hover_cursor = None;
                server_ctx.hover_cursor_3d = None;

                let current_dock = DOCKMANAGER.read().unwrap().dock.clone();
                if current_dock != "Palette" {
                    self.previous_dock = if current_dock.is_empty() {
                        None
                    } else {
                        Some(current_dock)
                    };
                }
                self.previous_sidebar_mode = Some(*SIDEBARMODE.read().unwrap());
                *SIDEBARMODE.write().unwrap() = SidebarMode::Palette;

                DOCKMANAGER.write().unwrap().set_dock(
                    "Palette".into(),
                    ui,
                    ctx,
                    project,
                    server_ctx,
                );
                true
            }
            DeActivate => {
                server_ctx.palette_tool_active = false;
                server_ctx.curr_map_tool_type = MapToolType::General;
                server_ctx.hover_cursor = None;
                server_ctx.hover_cursor_3d = None;
                if let Some(mode) = self.previous_sidebar_mode.take() {
                    *SIDEBARMODE.write().unwrap() = mode;
                }
                if DOCKMANAGER.read().unwrap().dock == "Palette"
                    && let Some(prev) = self.previous_dock.take()
                {
                    DOCKMANAGER
                        .write()
                        .unwrap()
                        .set_dock(prev, ui, ctx, project, server_ctx);
                }
                true
            }
            _ => false,
        }
    }
}