raekna-ui 0.2.1

This crate contains functionality to draw a plain text calculator using wgpu.
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
123
124
125
126
127
128

use std::time::Instant;

use raekna_common::{EditPosition, RCalculator};

use super::{dimensions::Dimensions, selection::Selection, text_buffer::TextBuffer};
use crate::{
    constants::TEXT_PADDING,
    graphics::controls::{caret_position::CaretPosition, Controls},
};

pub struct Content {
    pub calculator: Box<dyn RCalculator>,
    pub text_buffer: TextBuffer,
    pub selection: Selection,
    pub controls: Controls,
}

impl Content {
    pub fn new(calculator: Box<dyn RCalculator>, dimensions: &mut Dimensions) -> Self {
        let text_buffer = {
            let lines = calculator.get_all_lines();
            TextBuffer::new(lines, dimensions)
        };
        dimensions.scroll_ratio = {
            let num_lines = text_buffer.line_widths().len();
            let space_needed =
                TEXT_PADDING + num_lines as f32 * (TEXT_PADDING + dimensions.glyph_height());
            let space_available = dimensions.window_height();
            space_available / space_needed
        };
        let caret_position = CaretPosition::new(text_buffer.line_widths());
        let selection = Selection::new(caret_position);
        let controls = Controls::new(dimensions, &caret_position);

        Self {
            calculator,
            text_buffer,
            selection,
            controls,
        }
    }

    pub fn update(&mut self, dimensions: &Dimensions) {
        self.controls
            .update(dimensions, self.text_buffer.line_widths());
    }

    pub fn update_time(&mut self) -> (bool, Option<Instant>) {
        self.controls.update_time()
    }

    pub fn handle_line_updates(&mut self, dimensions: &Dimensions) {
        let lines = self.calculator.get_all_lines();
        self.text_buffer.update(lines, dimensions);
    }

    pub fn update_caret_position(&mut self, dimensions: &Dimensions) {
        self.controls
            .update_caret_position(dimensions, &self.selection.caret_position());
    }

    pub fn get_edit_selection(&self) -> (EditPosition, Option<EditPosition>) {
        let root_position = self
            .selection
            .root_position()
            .and_then(|pos| self.get_caret_position(pos));
        let caret_position = self
            .get_caret_position(self.selection.caret_position())
            .unwrap_or(CaretPosition {
                line: 0,
                column: 0,
                actual_column: 0,
            });
        let mut selection = Selection::new(caret_position);
        selection.set_root(root_position);
        match selection.as_ordered() {
            Some((start, end)) => (
                EditPosition::new(start.line, start.column),
                Some(EditPosition::new(end.line, end.column)),
            ),
            None => (
                EditPosition::new(caret_position.line, caret_position.column),
                None,
            ),
        }
    }

    pub fn handle_selection(&mut self, dimensions: &Dimensions, selection: Selection) {
        match selection {
            Selection::Some {
                caret_position,
                root_position,
            } => {
                self.selection.set_selection(caret_position, root_position);
                let line_widths = self.text_buffer.line_widths();
                self.controls
                    .show_selection(dimensions, line_widths, caret_position, root_position)
            }
            Selection::None(caret_position) => {
                self.selection.set_position(caret_position);
                self.controls.hide_selection();
            }
        }
    }

    fn get_caret_position(&self, caret_position: CaretPosition) -> Option<CaretPosition> {
        let line_widths = self.text_buffer.line_widths();
        let line_counts = self.text_buffer.line_counts();
        let mut line_offset = 0;
        let mut line_number = caret_position.line;
        line_counts.iter().enumerate().find_map(|(index, count)| {
            if line_number < *count {
                let widths =
                    (line_offset..line_offset + line_number).fold(0, |sum, i| sum + line_widths[i]);
                let column = widths + caret_position.column;
                Some(CaretPosition {
                    line: index,
                    column,
                    actual_column: column,
                })
            } else {
                line_offset += *count;
                line_number -= *count;
                None
            }
        })
    }
}