Struct Layer

Source

pub struct Layer<K> {
    pub key: K,
    pub frame: Rectangle,
    pub offset: Point,
}

Expand description

One render layer used by stack-style presentation.

Fields§

§key: K

Stable layer key.

§frame: Rectangle

Base frame for the layer.

§offset: Point

Translation offset applied during animation.

Implementations§

Source §

impl<K> Layer<K>

Source

pub const fn new(key: K, frame: Rectangle, offset: Point) -> Self

Creates a layer.

Examples found in repository ?

src/stack_view.rs (line 95)

80    pub fn root(frame: Rectangle, title: Localized<'a>) -> Self {
81        let header_height = HEADER_HEIGHT.min(frame.size.height.saturating_sub(1));
82        let header = Rectangle::new(frame.top_left, Size::new(frame.size.width, header_height));
83        let body = Rectangle::new(
84            frame.top_left + Point::new(0, header_height as i32),
85            Size::new(
86                frame.size.width,
87                frame.size.height.saturating_sub(header_height),
88            ),
89        );
90        Self {
91            frame,
92            header,
93            body,
94            layers: StackLayers {
95                base: Layer::new((), body, Point::zero()),
96                overlay: None,
97            },
98            back_button: None,
99            back_title: None,
100            active_title: HeaderTitle {
101                title,
102                center: header.center(),
103            },
104            secondary_title: None,
105        }
106    }

More examples

Hide additional examples

src/stack.rs (line 174)

172    pub fn layers(&self, frame: Rectangle) -> StackLayers<K> {
173        let width = frame.size.width as i32;
174        let idle = Layer::new(self.top(), frame, Point::zero());
175
176        match self.transition {
177            None => StackLayers {
178                base: idle,
179                overlay: None,
180            },
181            Some(Transition::Push {
182                from,
183                to,
184                animation,
185            }) => {
186                let progress = animation.progress_permille();
187                let base = Layer::new(from, frame, Point::zero());
188                let overlay = Layer::new(to, frame, Point::new(lerp_i32(width, 0, progress), 0));
189                StackLayers {
190                    base,
191                    overlay: Some(overlay),
192                }
193            }
194            Some(Transition::Pop {
195                from,
196                to,
197                animation,
198            }) => {
199                let progress = animation.progress_permille();
200                let base = Layer::new(to, frame, Point::zero());
201                let overlay = Layer::new(from, frame, Point::new(lerp_i32(0, width, progress), 0));
202                StackLayers {
203                    base,
204                    overlay: Some(overlay),
205                }
206            }
207        }
208    }

Source

pub fn translated_frame(&self) -> Rectangle

Returns the translated frame after applying the current offset.

Examples found in repository ?

src/containers.rs (line 180)

175    pub fn motion(&self, frame: Rectangle) -> Option<StackMotion> {
176        let nav = self.nav_view(frame);
177        nav.layers.overlay.map(|overlay| StackMotion {
178            header: nav.header,
179            body: nav.body,
180            overlay: overlay.translated_frame(),
181        })
182    }

More examples

Hide additional examples

src/app/render.rs (line 57)

52    pub fn stack_motion(&self, bounds: Rectangle) -> Option<StackMotion> {
53        let nav = self.nav_view(bounds);
54        nav.layers.overlay.map(|overlay| StackMotion {
55            header: nav.header,
56            body: nav.body,
57            overlay: overlay.translated_frame(),
58        })
59    }