Struct ModalLayer

Source

pub struct ModalLayer<M> {
    pub modal: M,
    pub panel: Rectangle,
    pub y_offset: i32,
    pub dim_alpha: u8,
}

Expand description

Render layer for a modal presentation.

Fields§

§modal: M

Modal identifier.

§panel: Rectangle

Settled panel frame.

§y_offset: i32

Vertical offset applied during animation.

§dim_alpha: u8

Backdrop dimming alpha.

Implementations§

Source §

impl<M> ModalLayer<M>

Source

pub const fn new( modal: M, panel: Rectangle, y_offset: i32, dim_alpha: u8, ) -> Self

Creates a modal layer.

Examples found in repository ?

src/modal.rs (line 105)

100    pub fn current_with_panel(&self, bounds: Rectangle, panel: Rectangle) -> Option<ModalLayer<M>> {
101        let offscreen = offscreen_offset(bounds, panel);
102
103        match self.state {
104            ModalState::Hidden => None,
105            ModalState::Visible { modal } => Some(ModalLayer::new(modal, panel, 0, DIM_ALPHA_MAX)),
106            ModalState::Showing { modal, animation } => {
107                let progress = animation.progress_permille();
108                Some(ModalLayer::new(
109                    modal,
110                    panel,
111                    lerp_i32(offscreen, 0, progress),
112                    lerp_u8(0, DIM_ALPHA_MAX, progress),
113                ))
114            }
115            ModalState::Hiding { modal, animation } => {
116                let progress = animation.progress_permille();
117                Some(ModalLayer::new(
118                    modal,
119                    panel,
120                    lerp_i32(0, offscreen, progress),
121                    lerp_u8(DIM_ALPHA_MAX, 0, progress),
122                ))
123            }
124        }
125    }

Source

pub fn translated_panel(&self) -> Rectangle

Returns the translated panel frame after applying y_offset.

Examples found in repository ?

src/alert_host/mod.rs (line 134)

110    pub fn handle_touch(
111        &mut self,
112        touch: TouchEvent,
113        bounds: Rectangle,
114        theme: &FsTheme,
115        i18n: &I18n<'a>,
116    ) -> AlertHostResponse<Modal> {
117        let Some(alert) = self.alert.as_mut() else {
118            return AlertHostResponse {
119                action: None,
120                captured: false,
121                redraw: false,
122            };
123        };
124
125        let panel = alert.panel(bounds, theme, i18n);
126        let Some(layer) = self.host.current_with_panel(bounds, panel) else {
127            return AlertHostResponse {
128                action: None,
129                captured: false,
130                redraw: false,
131            };
132        };
133
134        let response = alert.handle_touch(touch, layer.translated_panel());
135        if let Some(action) = response.action {
136            self.host.dismiss();
137            return AlertHostResponse {
138                action: Some((alert.key(), action)),
139                captured: true,
140                redraw: true,
141            };
142        }
143
144        AlertHostResponse {
145            action: None,
146            captured: true,
147            redraw: response.redraw,
148        }
149    }
150
151    /// Draws the current alert and dimming layer.
152    pub fn draw<D>(&self, display: &mut D, bounds: Rectangle, theme: &FsTheme, i18n: &I18n<'a>)
153    where
154        D: UiCanvas,
155    {
156        let Some(alert) = self.alert.as_ref() else {
157            return;
158        };
159        let Some(layer) = self.layer(bounds, theme, i18n) else {
160            return;
161        };
162
163        display.dim_rect(bounds, layer.dim_alpha);
164        alert.draw(display, layer.translated_panel(), theme, i18n);
165    }