duckyscript 0.1.0

parser for duckyscript
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

use egui::{self, Color32, ScrollArea, TextEdit, TextFormat, Vec2, text::LayoutSection};

use crate::parser::{get_duckyscript_tokens, DuckyScriptTokens};

#[derive(Default)]
pub struct DuckyScriptCodeView {
    syntax_highlight: egui::text::LayoutJob,
}

impl DuckyScriptCodeView {
    pub fn ui(&mut self, ui: &mut egui::Ui, code: &mut String) {
        ScrollArea::vertical().show(ui, |ui| {
            let mut layouter = |ui: &egui::Ui, code: &str, wrap_width: f32| {
                //self.syntax_highlight.wrap.max_width = wrap_width;
                let mut s = egui::text::LayoutJob::simple(
                    code.into(),
                    egui::FontId::monospace(12.0),
                    egui::Color32::DARK_GRAY
                    ,
                    f32::INFINITY,
                );
                s.sections = self.syntax_highlight.sections.clone();
                return ui.fonts().layout_job(s);
                //eprintln!("{:?}", self.syntax_highlight);

                //ui.fonts().layout_job(self.syntax_highlight.clone())
            };

            ui.add_sized(
                ui.available_size(),
                egui::TextEdit::multiline(code)
                    .code_editor()
                    .desired_width(f32::INFINITY)
                    .font(egui::TextStyle::Monospace) // for cursor height
                    .layouter(&mut layouter),
            )
        });
    }

    pub fn update_syntax_highlight(&mut self, code: &str, tokens: DuckyScriptTokens, egui_style: &egui::Style) {
        self.syntax_highlight = highlight_duckyscript(code, tokens, egui_style);
    }
}

fn highlight_duckyscript(
    code: &str,
    tokens: DuckyScriptTokens,
    egui_style: &egui::Style,
) -> egui::text::LayoutJob {
    let mut job = egui::text::LayoutJob{
        text: code.into(),
        ..Default::default()
    };
    return job;
    highlight_tokens(&mut job, tokens, egui_style);

    job
}
fn highlight_tokens(
    job: &mut egui::text::LayoutJob,
    tokens: DuckyScriptTokens,
    egui_style: &egui::Style,
) {
    use crate::parser::ducky::Rule;

    for token in tokens.into_inner() {
        let span = token.as_span();
        match token.as_rule() {
            Rule::builtin_fn => {
                
            }
            Rule::variable_def => {
                job.sections.push(LayoutSection {
                    leading_space: 0.0,
                    byte_range: span.start()..span.start()+5,
                    format: TextFormat {
                        font_id: egui::FontId::monospace(12.0),
                        color: Color32::from_rgb(255, 100, 100),
                        ..Default::default()
                    },
                });
            }
            Rule::while_block => {
                job.sections.push(LayoutSection {
                    leading_space: 0.0,
                    byte_range: span.start()..span.start()+5,
                    format: TextFormat {
                        font_id: egui::FontId::monospace(12.0),
                        color: Color32::from_rgb(255, 100, 100),
                        ..Default::default()
                    },
                });
            }
            Rule::EOI => break,
            _ => {
                break
            },
        };
        highlight_tokens(job, token, egui_style);
    }
}