zte 0.1.5

A buffer/window-driven text editor that takes inspiration from Howl
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

use vek::*;
use crate::{
    Canvas,
    Event,
    Dir,
    BufferHandle,
};
use super::{
    Context,
    Element,
};

enum Action {
    Quit,
}

pub struct Confirm {
    action: Action,
}

impl Confirm {
    pub fn quit(ctx: &mut Context) -> Self {
        Self { action: Action::Quit }
    }

    pub fn cancel(self, ctx: &mut Context) {}
}

impl Element for Confirm {
    type Response = Result<(), Event>;

    fn handle(&mut self, ctx: &mut Context, event: Event) -> Self::Response {
        let recent_count = ctx.state.recent_buffers().len();
        match &self.action {
            Action::Quit => match event {
                Event::Insert('y') => return Err(Event::Quit),
                Event::Insert('n') => ctx.secondary_events.push_back(Event::CloseMenu),
                event @ Event::Escape => return Err(event),
                _ => {},
            },
        }
        Ok(())
    }

    fn update(&mut self, ctx: &mut Context, canvas: &mut impl Canvas, active: bool) {
        // Todo
    }

    fn render(&self, ctx: &mut Context, canvas: &mut impl Canvas, active: bool) {
        let sz = canvas.size();
        let mut canvas = canvas.window(Rect::new(
            (sz.w / 2).saturating_sub(sz.w / 3),
            (sz.h / 2).saturating_sub(sz.h / 6),
            sz.w * 2 / 3,
            sz.h * 2 / 6,
        ));

        // Frame
        let sz = canvas.size();
        canvas.rectangle(Vec2::zero(), sz, ' '.into());
        canvas.frame();

        let title = format!("[Confirm]");
        canvas.write_str(Vec2::new((sz.w.saturating_sub(title.len())) / 2, 0), &title);

        // Entries
        let mut canvas = canvas.window(Rect::new(
            1,
            1,
            canvas.size().w.saturating_sub(2),
            canvas.size().h.saturating_sub(2),
        ));

        let text = match &self.action {
            Action::Quit => format!(
                "Quit and lose unsaved work? (y/n)\n\nThe following files are unsaved:\n{}",
                ctx.state
                    .recent_buffers()
                    .flat_map(|b| ctx.state.get_buffer(b))
                    .filter(|b| b.is_unsaved())
                    .map(|b| b.title())
                    .collect::<Vec<_>>()
                    .join("\n"),
            ),
        };
        for (i, line) in text.lines().enumerate() {
            let x = canvas.size().w.saturating_sub(line.chars().count()) / 2;
            canvas.write_str(Vec2::new(x, i + 1), line);
        }
    }
}