quvyta-framework 0.1.20

A Rust framework for building terminal applications
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

//! Copying, pasting and reading the clipboard.

use std::time::Duration;

use super::Engine;
use crate::event::Event;
use crate::runtime::App;
use crate::runtime::clipboard::{ClipboardEvent, ReadStep};

/// What a clipboard read is for.
pub(super) enum ClipboardRead<Msg> {
    /// Paste the text into the focused widget, or offer it to the application.
    Paste,
    /// Deliver the text to the application, see [`Command::read_clipboard`](crate::runtime::Command::read_clipboard).
    Message(Box<dyn FnOnce(Option<String>) -> Msg>),
    /// Only learn whether there is text to paste, for Paste menu entries.
    Probe,
}

impl<A: App> Engine<A> {
    /// Offers pasted text to the focused widget, then to the application.
    pub(super) fn paste(&mut self, text: String, now: Duration) {
        let targets = self.keyboard_targets();
        self.dirty = true;
        if self.dispatch(&targets, &Event::Paste(text.clone()), now).is_none()
            && let Some(message) = self.app.clipboard(&ClipboardEvent::Pasted(text))
        {
            self.update(message);
        }
    }

    /// Remembers copied text and queues it for the terminal clipboard.
    pub(super) fn store_copy(&mut self, text: String) {
        self.clipboard_text = Some(text.clone());
        self.clipboard.push(text);
        self.interaction.can_paste = true;
    }

    /// Reads the clipboard for `read`: the system tool, then the terminal, then the text copied
    /// last inside the application; see [`ClipboardReader`]. Reads asked for while one runs
    /// share its result.
    pub(super) fn read_clipboard(&mut self, read: ClipboardRead<A::Msg>, now: Duration) {
        self.clipboard_reads.push(read);
        if self.clipboard_reader.is_reading() {
            return;
        }
        let step = self.clipboard_reader.start();
        self.clipboard_step(step, now);
    }

    pub(super) fn clipboard_step(&mut self, step: ReadStep, now: Duration) {
        match step {
            ReadStep::Waiting => {}
            ReadStep::AskTerminal => self.terminal_query = true,
            ReadStep::Done(text) => self.finish_clipboard(text, now),
        }
    }

    /// Checks on a clipboard read whose system tool runs on a thread.
    pub(crate) fn poll_clipboard(&mut self, now: Duration) {
        if self.clipboard_reader.is_reading() {
            let step = self.clipboard_reader.poll();
            self.clipboard_step(step, now);
        }
    }

    /// The terminal's answer to the OSC 52 clipboard query, `None` when it did not answer in time.
    pub(crate) fn terminal_clipboard(&mut self, text: Option<String>, now: Duration) {
        let step = self.clipboard_reader.terminal_answer(text);
        self.clipboard_step(step, now);
    }

    /// Delivers the text a clipboard read found, or the text copied last inside the application.
    pub(super) fn finish_clipboard(&mut self, text: Option<String>, now: Duration) {
        let text = text.or_else(|| self.clipboard_text.clone());
        self.interaction.can_paste = text.is_some();
        self.dirty = true;
        for read in std::mem::take(&mut self.clipboard_reads) {
            match read {
                ClipboardRead::Paste => {
                    if let Some(text) = &text {
                        self.paste(text.clone(), now);
                    }
                }
                ClipboardRead::Message(message) => {
                    let message = message(text.clone());
                    self.update(message);
                }
                ClipboardRead::Probe => {}
            }
        }
    }

    /// A copy made by a widget or the mouse selection: stored and reported to the application.
    pub(super) fn copy_from_ui(&mut self, text: String) {
        self.store_copy(text.clone());
        if let Some(message) = self.app.clipboard(&ClipboardEvent::Copied(text)) {
            self.update(message);
        }
    }
}