1use 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
31pub(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 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 let target_top_left = target_rect.origin.map(to_pixel);
225 let target_bottom_right = target_rect.max().map(to_pixel);
226
227 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 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 (ScrollLogicalPosition::Start, false) | (ScrollLogicalPosition::End, true) => {
297 element_start
298 },
299 (ScrollLogicalPosition::End, false) | (ScrollLogicalPosition::Start, true) => {
302 element_end - container_size
303 },
304 (ScrollLogicalPosition::Center, ..) => {
307 element_start + (element_size - container_size) / 2.0
308 },
309 (ScrollLogicalPosition::Nearest, ..) => {
311 let scrollport_start = 0.;
312 let scrollport_end = container_size;
313
314 if (element_start < scrollport_start && element_size <= container_size) ||
319 (element_end > scrollport_end && element_size >= container_size)
320 {
321 element_start
322 }
323 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 else {
335 0.
336 }
337 },
338 }
339 }
340}