cranpose-ui 0.9.42

Composable widgets, text, layouts and input for Cranpose apps
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

//! What a text field shows: its text after its output transformation, and
//! how offsets map between the two, built once per change of either.

use std::{cell::RefCell, rc::Rc};

use cranpose_foundation::text::{OffsetMapping, OutputTransformation, TextFieldState, TextRange};

use crate::text::AnnotatedString;

/// A field's text as shown. Layout, drawing and hit tests work in offsets
/// of the shown text; editing works in offsets of the text.
pub(crate) struct FieldPresentation {
    pub(crate) shown: Rc<AnnotatedString>,
    /// `None` shows the text as it is.
    mapping: Option<OffsetMapping>,
}

impl FieldPresentation {
    pub(crate) fn text(&self) -> &str {
        &self.shown.text
    }

    /// Where an offset of the text is shown.
    pub(crate) fn to_shown(&self, offset: usize) -> usize {
        self.mapping
            .as_ref()
            .map_or(offset, |mapping| mapping.to_shown(offset))
            .min(self.shown.text.len())
    }

    /// The offset of the text a shown offset stands for.
    pub(crate) fn to_source(&self, offset: usize) -> usize {
        self.mapping
            .as_ref()
            .map_or(offset, |mapping| mapping.to_source(offset))
    }

    /// The shown bounds of a range of the text, lower first.
    pub(crate) fn range_to_shown(&self, range: TextRange) -> (usize, usize) {
        (self.to_shown(range.min()), self.to_shown(range.max()))
    }
}

/// Keeps a field's presentation until its state, text or transformation
/// changes, so a frame reads the shown text without copying it.
#[derive(Default)]
pub(crate) struct PresentationCache {
    transformation: RefCell<Option<OutputTransformation>>,
    entry: RefCell<Option<CachedPresentation>>,
}

struct CachedPresentation {
    state: TextFieldState,
    revision: u64,
    presentation: Rc<FieldPresentation>,
}

impl PresentationCache {
    /// Sets the field's transformation, which its composition gives it.
    /// Answers whether it changed.
    pub(crate) fn set_transformation(&self, transformation: Option<OutputTransformation>) -> bool {
        if *self.transformation.borrow() == transformation {
            return false;
        }
        *self.transformation.borrow_mut() = transformation;
        self.entry.borrow_mut().take();
        true
    }

    pub(crate) fn get(&self, state: TextFieldState) -> Rc<FieldPresentation> {
        let revision = state.text_revision();
        if let Some(cached) = self.entry.borrow().as_ref()
            && cached.state == state
            && cached.revision == revision
        {
            return Rc::clone(&cached.presentation);
        }
        let transformation = self.transformation.borrow();
        let presentation = Rc::new(state.with_text(|text| match transformation.as_ref() {
            None => FieldPresentation {
                shown: Rc::new(AnnotatedString::from(text)),
                mapping: None,
            },
            Some(transformation) => {
                let shown = transformation.apply(text);
                FieldPresentation {
                    shown: Rc::new(AnnotatedString::from(shown.text)),
                    mapping: Some(shown.mapping),
                }
            }
        }));
        drop(transformation);
        *self.entry.borrow_mut() = Some(CachedPresentation {
            state,
            revision,
            presentation: Rc::clone(&presentation),
        });
        presentation
    }
}