inlyne 0.5.1

Introducing Inlyne, a GPU powered yet browserless tool to help you quickly view markdown files in the blink of an eye.
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

use crate::utils::{dist_between_points, Point};
use std::time::{Duration, Instant};

const CLICK_TOLERANCE: Duration = Duration::from_millis(300);
const MAX_CLICK_DIST: f32 = 5.0;

#[derive(PartialEq, Debug)]
pub enum SelectionMode {
    Word,
    Line,
}

#[derive(Debug, Default)]
pub enum SelectionKind {
    Drag {
        start: Point,
        end: Point,
    },
    Click {
        mode: SelectionMode,
        time: Instant,
        position: Point,
    },
    Start {
        position: Point,
        time: Instant,
    },
    #[default]
    None,
}

#[derive(Default)]
pub struct Selection {
    pub selection: SelectionKind,
    pub text: String,
}

impl Selection {
    pub const fn new() -> Self {
        Self {
            selection: SelectionKind::None,
            text: String::new(),
        }
    }
    pub fn is_none(&self) -> bool {
        matches!(self.selection, SelectionKind::None)
    }
    pub fn start(&mut self, position: Point) {
        self.selection = SelectionKind::Start {
            position,
            time: Instant::now(),
        }
    }

    #[must_use]
    pub fn handle_drag(&mut self, new_position: Point) -> bool {
        self.text.clear();
        match &mut self.selection {
            SelectionKind::Start { position, .. } => {
                self.selection = SelectionKind::Drag {
                    start: *position,
                    end: new_position,
                };
            }
            SelectionKind::Drag { end, .. } => *end = new_position,
            _ => return false,
        }
        true
    }

    pub fn add_position(&mut self, new_position: Point) {
        self.text.clear();

        match &self.selection {
            SelectionKind::Click {
                mode,
                time,
                position,
            } => {
                if mode == &SelectionMode::Word
                    && time.elapsed() < CLICK_TOLERANCE
                    && dist_between_points(position, &new_position) < MAX_CLICK_DIST
                {
                    self.selection = SelectionKind::Click {
                        time: Instant::now(),
                        mode: SelectionMode::Line,
                        position: new_position,
                    };
                } else {
                    self.start(new_position)
                }
            }
            SelectionKind::Start { position, time } => {
                if time.elapsed() < CLICK_TOLERANCE
                    && dist_between_points(position, &new_position) < MAX_CLICK_DIST
                {
                    self.selection = SelectionKind::Click {
                        time: Instant::now(),
                        mode: SelectionMode::Word,
                        position: new_position,
                    };
                } else {
                    self.start(new_position)
                }
            }
            _ => self.start(new_position),
        }
    }

    pub fn add_line(&mut self, str: &str) {
        self.text.push_str(str);
        self.text.push('\n');
    }
}