Skip to main content

script/dom/window/
scrolling_box.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::Cell;
6
7use app_units::Au;
8use euclid::{Rect, Vector2D};
9use js::context::JSContext;
10use layout_api::{AxesOverflow, ScrollContainerQueryFlags, WritingModeExt};
11use script_bindings::codegen::GenericBindings::WindowBinding::ScrollBehavior;
12use script_bindings::inheritance::Castable;
13use script_bindings::root::DomRoot;
14use style::logical_geometry::WritingMode;
15use style::values::computed::Overflow;
16use style_traits::CSSPixel;
17use webrender_api::units::{LayoutSize, LayoutVector2D};
18
19use crate::dom::bindings::codegen::Bindings::ElementBinding::ScrollLogicalPosition;
20use crate::dom::node::{Node, NodeTraits};
21use crate::dom::types::{Document, Element};
22
23pub(crate) struct ScrollingBox {
24    target: ScrollingBoxSource,
25    overflow: AxesOverflow,
26    writing_mode: WritingMode,
27    cached_content_size: Cell<Option<LayoutSize>>,
28    cached_size: Cell<Option<LayoutSize>>,
29}
30
31/// Represents a scrolling box that can be either an element or the viewport
32/// <https://drafts.csswg.org/cssom-view/#scrolling-box>
33pub(crate) enum ScrollingBoxSource {
34    Element(DomRoot<Element>),
35    Viewport(DomRoot<Document>),
36}
37
38#[derive(Copy, Clone)]
39pub(crate) enum ScrollingBoxAxis {
40    X,
41    Y,
42}
43
44#[derive(Copy, Clone)]
45pub(crate) enum ScrollRequirement {
46    Always,
47    IfNotVisible,
48}
49
50impl ScrollRequirement {
51    fn compute_need_scroll(
52        &self,
53        element_start: f32,
54        element_end: f32,
55        container_size: f32,
56    ) -> bool {
57        match self {
58            ScrollRequirement::Always => true,
59            ScrollRequirement::IfNotVisible => {
60                let scrollport_start = 0.;
61                let scrollport_end = container_size;
62
63                element_end <= scrollport_start || element_start >= scrollport_end
64            },
65        }
66    }
67}
68
69#[derive(Copy, Clone)]
70pub(crate) struct ScrollAxisState {
71    pub(crate) position: ScrollLogicalPosition,
72    pub(crate) requirement: ScrollRequirement,
73}
74
75impl ScrollAxisState {
76    pub fn new_always_scroll_position(position: ScrollLogicalPosition) -> Self {
77        ScrollAxisState {
78            position,
79            requirement: ScrollRequirement::Always,
80        }
81    }
82}
83
84impl ScrollingBox {
85    pub(crate) fn new(
86        target: ScrollingBoxSource,
87        overflow: AxesOverflow,
88        writing_mode: WritingMode,
89    ) -> Self {
90        Self {
91            target,
92            overflow,
93            writing_mode,
94            cached_content_size: Default::default(),
95            cached_size: Default::default(),
96        }
97    }
98
99    pub(crate) fn target(&self) -> &ScrollingBoxSource {
100        &self.target
101    }
102
103    pub(crate) fn is_viewport(&self) -> bool {
104        matches!(self.target, ScrollingBoxSource::Viewport(..))
105    }
106
107    pub(crate) fn scroll_position(&self, cx: &mut JSContext) -> LayoutVector2D {
108        match &self.target {
109            ScrollingBoxSource::Element(element) => element
110                .owner_window()
111                .scroll_offset_query(cx, element.upcast::<Node>()),
112            ScrollingBoxSource::Viewport(document) => document.window().scroll_offset(cx),
113        }
114    }
115
116    pub(crate) fn content_size(&self, cx: &mut JSContext) -> LayoutSize {
117        if let Some(content_size) = self.cached_content_size.get() {
118            return content_size;
119        }
120
121        let (document, node_to_query) = match &self.target {
122            ScrollingBoxSource::Element(element) => {
123                (element.owner_document(), Some(element.upcast()))
124            },
125            ScrollingBoxSource::Viewport(document) => (document.clone(), None),
126        };
127
128        let content_size = document
129            .window()
130            .scrolling_area_query(cx, node_to_query)
131            .size
132            .to_f32()
133            .cast_unit();
134        self.cached_content_size.set(Some(content_size));
135        content_size
136    }
137
138    pub(crate) fn size(&self, cx: &mut JSContext) -> LayoutSize {
139        if let Some(size) = self.cached_size.get() {
140            return size;
141        }
142
143        let size = match &self.target {
144            ScrollingBoxSource::Element(element) => {
145                element.client_rect(cx).size.to_f32().cast_unit()
146            },
147            ScrollingBoxSource::Viewport(document) => {
148                document.window().viewport_details().size.cast_unit()
149            },
150        };
151        self.cached_size.set(Some(size));
152        size
153    }
154
155    pub(crate) fn parent(&self) -> Option<ScrollingBox> {
156        match &self.target {
157            ScrollingBoxSource::Element(element) => {
158                element.scrolling_box(ScrollContainerQueryFlags::empty())
159            },
160            ScrollingBoxSource::Viewport(_) => None,
161        }
162    }
163
164    pub(crate) fn node(&self) -> &Node {
165        match &self.target {
166            ScrollingBoxSource::Element(element) => element.upcast(),
167            ScrollingBoxSource::Viewport(document) => document.upcast(),
168        }
169    }
170
171    pub(crate) fn scroll_to(
172        &self,
173        cx: &mut JSContext,
174        position: LayoutVector2D,
175        behavior: ScrollBehavior,
176    ) {
177        match &self.target {
178            ScrollingBoxSource::Element(element) => {
179                element
180                    .owner_window()
181                    .scroll_an_element(cx, element, position.x, position.y, behavior);
182            },
183            ScrollingBoxSource::Viewport(document) => {
184                document
185                    .window()
186                    .scroll(cx, position.x, position.y, behavior);
187            },
188        }
189    }
190
191    pub(crate) fn can_keyboard_scroll_in_axis(
192        &self,
193        cx: &mut JSContext,
194        axis: ScrollingBoxAxis,
195    ) -> bool {
196        let overflow = match axis {
197            ScrollingBoxAxis::X => self.overflow.x,
198            ScrollingBoxAxis::Y => self.overflow.y,
199        };
200        if overflow == Overflow::Hidden {
201            return false;
202        }
203        match axis {
204            ScrollingBoxAxis::X => self.content_size(cx).width > self.size(cx).width,
205            ScrollingBoxAxis::Y => self.content_size(cx).height > self.size(cx).height,
206        }
207    }
208
209    /// <https://drafts.csswg.org/cssom-view/#determine-the-scroll-into-view-position>
210    pub(crate) fn determine_scroll_into_view_position(
211        &self,
212        cx: &mut JSContext,
213        block: ScrollAxisState,
214        inline: ScrollAxisState,
215        target_rect: Rect<Au, CSSPixel>,
216    ) -> LayoutVector2D {
217        let device_pixel_ratio = self.node().owner_window().device_pixel_ratio().get();
218        let to_pixel = |value: Au| value.to_nearest_pixel(device_pixel_ratio);
219
220        // Step 1 should be handled by the caller, and provided as |target_rect|.
221        // > Let target bounding border box be the box represented by the return value
222        // > of invoking Element’s getBoundingClientRect(), if target is an Element,
223        // > or Range’s getBoundingClientRect(), if target is a Range.
224        let target_top_left = target_rect.origin.map(to_pixel);
225        let target_bottom_right = target_rect.max().map(to_pixel);
226
227        // The rest of the steps diverge from the specification here, but essentially try
228        // to follow it using our own geometry types.
229        let (adjusted_element_top_left, adjusted_element_bottom_right) = match self.target() {
230            ScrollingBoxSource::Viewport(_) => (target_top_left, target_bottom_right),
231            ScrollingBoxSource::Element(scrolling_element) => {
232                let scrolling_padding_rect_top_left = scrolling_element
233                    .upcast::<Node>()
234                    .padding_box(cx)
235                    .unwrap_or_default()
236                    .origin
237                    .map(to_pixel);
238                (
239                    target_top_left - scrolling_padding_rect_top_left.to_vector(),
240                    target_bottom_right - scrolling_padding_rect_top_left.to_vector(),
241                )
242            },
243        };
244
245        let inline_flipped = self.writing_mode.is_inline_flipped();
246        let block_flipped = self.writing_mode.is_block_flipped();
247        let (x_scroll_axis_state, x_flipped, y_scroll_axis_state, y_flipped) =
248            if self.writing_mode.is_horizontal() {
249                (inline, inline_flipped, block, block_flipped)
250            } else {
251                (block, block_flipped, inline, inline_flipped)
252            };
253
254        let size = self.size(cx);
255        let current_scroll_position = self.scroll_position(cx);
256        Vector2D::new(
257            Self::calculate_scroll_position_one_axis(
258                x_scroll_axis_state,
259                adjusted_element_top_left.x,
260                adjusted_element_bottom_right.x,
261                size.width,
262                current_scroll_position.x,
263                x_flipped,
264            ),
265            Self::calculate_scroll_position_one_axis(
266                y_scroll_axis_state,
267                adjusted_element_top_left.y,
268                adjusted_element_bottom_right.y,
269                size.height,
270                current_scroll_position.y,
271                y_flipped,
272            ),
273        )
274    }
275
276    /// Step 10 from <https://drafts.csswg.org/cssom-view/#determine-the-scroll-into-view-position>.
277    fn calculate_scroll_position_one_axis(
278        state: ScrollAxisState,
279        element_start: f32,
280        element_end: f32,
281        container_size: f32,
282        current_scroll_offset: f32,
283        flipped: bool,
284    ) -> f32 {
285        if !state
286            .requirement
287            .compute_need_scroll(element_start, element_end, container_size)
288        {
289            return current_scroll_offset;
290        }
291
292        let element_size = element_end - element_start;
293        current_scroll_offset +
294            match (state.position, flipped) {
295                // Step 1 & 5: If inline is "start", then align element start edge with scrolling box start edge.
296                (ScrollLogicalPosition::Start, false) | (ScrollLogicalPosition::End, true) => {
297                    element_start
298                },
299                // Step 2 & 6: If inline is "end", then align element end edge with
300                // scrolling box end edge.
301                (ScrollLogicalPosition::End, false) | (ScrollLogicalPosition::Start, true) => {
302                    element_end - container_size
303                },
304                // Step 3 & 7: If inline is "center", then align the center of target bounding
305                // border box with the center of scrolling box in scrolling box’s inline base direction.
306                (ScrollLogicalPosition::Center, ..) => {
307                    element_start + (element_size - container_size) / 2.0
308                },
309                // Step 4 & 8: If inline is "nearest",
310                (ScrollLogicalPosition::Nearest, ..) => {
311                    let scrollport_start = 0.;
312                    let scrollport_end = container_size;
313
314                    // Step 4.2 & 8.2: If element start edge is outside scrolling box start edge and element
315                    // size is less than scrolling box size or If element end edge is outside
316                    // scrolling box end edge and element size is greater than scrolling box size:
317                    // Align element start edge with scrolling box start edge.
318                    if (element_start < scrollport_start && element_size <= container_size) ||
319                        (element_end > scrollport_end && element_size >= container_size)
320                    {
321                        element_start
322                    }
323                    // Step 4.3 & 8.3: If element end edge is outside scrolling box start edge and element
324                    // size is greater than scrolling box size or If element start edge is outside
325                    // scrolling box end edge and element size is less than scrolling box size:
326                    // Align element end edge with scrolling box end edge.
327                    else if (element_end > scrollport_end && element_size < container_size) ||
328                        (element_start < scrollport_start && element_size > container_size)
329                    {
330                        element_end - container_size
331                    }
332                    // Step 4.1 & 8.1: If element start edge and element end edge are both outside scrolling
333                    // box start edge and scrolling box end edge or an invalid situation: Do nothing.
334                    else {
335                        0.
336                    }
337                },
338            }
339    }
340}