inset-rendering 0.12.0

Render-object tree and layout for Inset
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
129
130
131

//! Flutter counterpart: `rendering/object.dart` (`RelayoutWhenSystemFontsChangeMixin`).

use std::time::Duration;

use inset_foundation::{App, Handle, Listenable, Listener};
use inset_painting::PaintingBinding;
use inset_scheduler::{FrameCallback, SchedulerBinding};

use crate::object::{RenderHandle, RenderObject};

/// Flutter's `RelayoutWhenSystemFontsChangeMixin` fields.
#[derive(Debug, Default)]
pub struct RelayoutWhenSystemFontsChangeData {
    has_pending_system_fonts_did_change_callback: bool,
}

impl RelayoutWhenSystemFontsChangeData {
    /// No pending system-fonts callback.
    pub const fn new() -> RelayoutWhenSystemFontsChangeData {
        RelayoutWhenSystemFontsChangeData {
            has_pending_system_fonts_did_change_callback: false,
        }
    }
}

/// Mixin for a [`RenderObject`] that relayouts when system fonts change.
///
/// System fonts can change when the OS installs or removes a font. Use this mixin if the
/// render object uses `TextPainter` or `Paragraph` to correctly update the text when it
/// happens.
pub trait RelayoutWhenSystemFontsChangeMixin: RenderObject {
    /// Mixin field access.
    fn relayout_when_system_fonts_change_data(
        self: RenderHandle<Self>,
        app: &App,
    ) -> &RelayoutWhenSystemFontsChangeData;

    /// See [`relayout_when_system_fonts_change_data`](Self::relayout_when_system_fonts_change_data).
    fn relayout_when_system_fonts_change_data_mut(
        self: RenderHandle<Self>,
        app: &mut App,
    ) -> &mut RelayoutWhenSystemFontsChangeData;

    /// A callback that is called when system fonts have changed.
    ///
    /// The framework defers the invocation of the callback to the
    /// `SchedulerPhase::TransientCallbacks` phase to ensure that the render object's text
    /// layout is still valid when user interactions are in progress (which usually take
    /// place during the idle phase).
    ///
    /// By default, `markNeedsLayout` is called on the render object implementing this mixin.
    ///
    /// Subclass should override this method to clear any extra cache that depend on
    /// font-related metrics.
    fn system_fonts_did_change(self: RenderHandle<Self>, app: &mut App) {
        self.as_render_object(app).mark_needs_layout(app);
    }

    /// Flutter's `attach` override body after `super.attach`.
    fn attach_system_fonts(self: RenderHandle<Self>, app: &mut App) {
        debug_assert!(
            !self
                .relayout_when_system_fonts_change_data(app)
                .has_pending_system_fonts_did_change_callback
        );
        PaintingBinding::instance(app)
            .system_fonts(app)
            .add_listener(app, self.system_fonts_listener());
    }

    /// Flutter's `detach` override body before `super.detach`.
    fn detach_system_fonts(self: RenderHandle<Self>, app: &mut App) {
        debug_assert!(
            !self
                .relayout_when_system_fonts_change_data(app)
                .has_pending_system_fonts_did_change_callback
        );
        PaintingBinding::instance(app)
            .system_fonts(app)
            .remove_listener(app, &self.system_fonts_listener());
    }

    fn system_fonts_listener(self: RenderHandle<Self>) -> Listener {
        Listener::handle_method(self.handle(), schedule_system_fonts_update::<Self>)
    }

    fn schedule_system_fonts_update(self: RenderHandle<Self>, app: &mut App) {
        if self
            .relayout_when_system_fonts_change_data(app)
            .has_pending_system_fonts_did_change_callback
        {
            return;
        }
        self.relayout_when_system_fonts_change_data_mut(app)
            .has_pending_system_fonts_did_change_callback = true;
        SchedulerBinding::schedule_frame_callback(
            app,
            FrameCallback::handle_method(self.handle(), run_system_fonts_update::<Self>),
            None,
            false,
            true,
        );
    }
}

fn schedule_system_fonts_update<T: RelayoutWhenSystemFontsChangeMixin>(
    this: Handle<T>,
    app: &mut App,
) {
    RenderHandle::from_handle(this).schedule_system_fonts_update(app);
}

fn run_system_fonts_update<T: RelayoutWhenSystemFontsChangeMixin>(
    this: Handle<T>,
    app: &mut App,
    _time_stamp: Duration,
) {
    let this = RenderHandle::from_handle(this);
    if app.is_disposed(this.handle()) {
        return;
    }
    debug_assert!(
        this.relayout_when_system_fonts_change_data(app)
            .has_pending_system_fonts_did_change_callback
    );
    this.relayout_when_system_fonts_change_data_mut(app)
        .has_pending_system_fonts_did_change_callback = false;
    if this.as_render_object(app).attached(app) {
        RelayoutWhenSystemFontsChangeMixin::system_fonts_did_change(this, app);
    }
}