jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
3 * Copyright (c) 2022, the SerenityOS developers.
4 *
5 * SPDX-License-Identifier: BSD-2-Clause
6 */
7
8#include <LibCore/Timer.h>
9#include <LibGUI/AbstractScrollableWidget.h>
10#include <LibGUI/Scrollbar.h>
11
12namespace GUI {
13
14AbstractScrollableWidget::AbstractScrollableWidget()
15{
16 REGISTER_READONLY_SIZE_PROPERTY("min_content_size", min_content_size);
17
18 m_vertical_scrollbar = add<AbstractScrollableWidgetScrollbar>(*this, Orientation::Vertical);
19 m_vertical_scrollbar->set_step(4);
20 m_vertical_scrollbar->on_change = [this](int) {
21 did_scroll();
22 update();
23 };
24
25 m_horizontal_scrollbar = add<AbstractScrollableWidgetScrollbar>(*this, Orientation::Horizontal);
26 m_horizontal_scrollbar->set_step(4);
27 m_horizontal_scrollbar->set_page_step(30);
28 m_horizontal_scrollbar->on_change = [this](int) {
29 did_scroll();
30 update();
31 };
32
33 m_corner_widget = add<Widget>();
34 m_corner_widget->set_fill_with_background_color(true);
35
36 m_automatic_scrolling_timer = add<Core::Timer>();
37 m_automatic_scrolling_timer->set_interval(50);
38 m_automatic_scrolling_timer->on_timeout = [this] {
39 automatic_scrolling_timer_did_fire();
40 };
41}
42
43void AbstractScrollableWidget::set_banner_widget(Widget* widget)
44{
45 if (m_banner_widget == widget)
46 return;
47 if (m_banner_widget)
48 remove_child(*m_banner_widget);
49 if (!widget)
50 return;
51
52 m_banner_widget = widget;
53 add_child(*m_banner_widget);
54}
55
56void AbstractScrollableWidget::handle_wheel_event(MouseEvent& event, Widget& event_source)
57{
58 if (!m_scrollbars_enabled) {
59 event.ignore();
60 return;
61 }
62
63 int wheel_delta_x { 0 };
64 bool vertical_scroll_hijacked { false };
65
66 if (event.shift() || &event_source == m_horizontal_scrollbar.ptr()) {
67 wheel_delta_x = event.wheel_delta_y();
68 vertical_scroll_hijacked = true;
69 }
70
71 if (event.wheel_delta_x() != 0) {
72 wheel_delta_x = event.wheel_delta_x();
73 }
74
75 if (wheel_delta_x != 0) {
76 // FIXME: The wheel delta multiplier should probably come from... somewhere?
77 horizontal_scrollbar().increase_slider_by(wheel_delta_x * 60);
78 }
79
80 if (!vertical_scroll_hijacked && event.wheel_delta_y() != 0) {
81 vertical_scrollbar().increase_slider_by(event.wheel_delta_y() * 20);
82 }
83}
84
85void AbstractScrollableWidget::mousewheel_event(MouseEvent& event)
86{
87 handle_wheel_event(event, *this);
88}
89
90void AbstractScrollableWidget::custom_layout()
91{
92 auto inner_rect = frame_inner_rect_for_size(size());
93 int height_wanted_by_banner_widget = m_banner_widget && m_banner_widget->is_visible() ? m_banner_widget->effective_min_size().height().as_int() : 0;
94 int height_wanted_by_horizontal_scrollbar = m_horizontal_scrollbar->is_visible() ? m_horizontal_scrollbar->effective_min_size().height().as_int() : 0;
95 int width_wanted_by_vertical_scrollbar = m_vertical_scrollbar->is_visible() ? m_vertical_scrollbar->effective_min_size().width().as_int() : 0;
96
97 if (m_banner_widget && m_banner_widget->is_visible()) {
98 m_banner_widget->set_relative_rect(
99 inner_rect.left(),
100 inner_rect.top(),
101 inner_rect.width(),
102 height_wanted_by_banner_widget);
103 }
104
105 {
106 int vertical_scrollbar_width = m_vertical_scrollbar->effective_min_size().width().as_int();
107 m_vertical_scrollbar->set_relative_rect(
108 inner_rect.right() + 1 - vertical_scrollbar_width,
109 inner_rect.top() + height_wanted_by_banner_widget,
110 vertical_scrollbar_width,
111 inner_rect.height() - height_wanted_by_horizontal_scrollbar - height_wanted_by_banner_widget);
112 }
113
114 {
115 int horizontal_scrollbar_height = m_horizontal_scrollbar->effective_min_size().height().as_int();
116 m_horizontal_scrollbar->set_relative_rect(
117 inner_rect.left(),
118 inner_rect.bottom() + 1 - horizontal_scrollbar_height,
119 inner_rect.width() - width_wanted_by_vertical_scrollbar,
120 horizontal_scrollbar_height);
121 }
122
123 m_corner_widget->set_visible(m_vertical_scrollbar->is_visible() && m_horizontal_scrollbar->is_visible());
124 if (m_corner_widget->is_visible()) {
125 Gfx::IntRect corner_rect { m_horizontal_scrollbar->relative_rect().right() + 1, m_vertical_scrollbar->relative_rect().bottom() + 1, width_occupied_by_vertical_scrollbar(), height_occupied_by_horizontal_scrollbar() };
126 m_corner_widget->set_relative_rect(corner_rect);
127 }
128}
129
130void AbstractScrollableWidget::resize_event(ResizeEvent& event)
131{
132 Frame::resize_event(event);
133 update_scrollbar_visibility();
134 update_scrollbar_ranges();
135}
136
137Gfx::IntSize AbstractScrollableWidget::available_size() const
138{
139 auto inner_size = Widget::content_size();
140 int available_width = max(inner_size.width() - m_size_occupied_by_fixed_elements.width(), 0);
141 int available_height = max(inner_size.height() - m_size_occupied_by_fixed_elements.height(), 0);
142 return { available_width, available_height };
143}
144
145Gfx::IntSize AbstractScrollableWidget::excess_size() const
146{
147 auto available_size = this->available_size();
148 int excess_height = max(0, m_content_size.height() - available_size.height());
149 int excess_width = max(0, m_content_size.width() - available_size.width());
150 return { excess_width, excess_height };
151}
152
153void AbstractScrollableWidget::set_should_hide_unnecessary_scrollbars(bool should_hide_unnecessary_scrollbars)
154{
155 if (m_should_hide_unnecessary_scrollbars == should_hide_unnecessary_scrollbars)
156 return;
157
158 m_should_hide_unnecessary_scrollbars = should_hide_unnecessary_scrollbars;
159 if (should_hide_unnecessary_scrollbars) {
160 update_scrollbar_ranges();
161 } else {
162 m_horizontal_scrollbar->set_visible(m_scrollbars_enabled);
163 m_vertical_scrollbar->set_visible(m_scrollbars_enabled);
164 }
165}
166
167void AbstractScrollableWidget::update_scrollbar_ranges()
168{
169 m_horizontal_scrollbar->set_range(0, excess_size().width());
170 m_horizontal_scrollbar->set_page_step(visible_content_rect().width() - m_horizontal_scrollbar->step());
171
172 m_vertical_scrollbar->set_range(0, excess_size().height());
173 m_vertical_scrollbar->set_page_step(visible_content_rect().height() - m_vertical_scrollbar->step());
174 update_scrollbar_visibility();
175}
176
177void AbstractScrollableWidget::update_scrollbar_visibility()
178{
179 if (!m_scrollbars_enabled) {
180 m_horizontal_scrollbar->set_visible(false);
181 m_vertical_scrollbar->set_visible(false);
182 return;
183 }
184 if (should_hide_unnecessary_scrollbars()) {
185 // If there has not been a min_size set, the content_size can be used as a substitute
186 auto effective_min_content_size = m_min_content_size;
187 if (m_min_content_size == Gfx::IntSize {})
188 effective_min_content_size = m_content_size;
189 int horizontal_buffer = rect().width() - 2 * frame_thickness() - effective_min_content_size.width();
190 int vertical_buffer = rect().height() - 2 * frame_thickness() - effective_min_content_size.height() - height_occupied_by_banner_widget();
191 bool horizontal_scrollbar_should_be_visible = false, vertical_scrollbar_should_be_visible = false;
192 vertical_scrollbar_should_be_visible = vertical_buffer < 0;
193 if (vertical_scrollbar_should_be_visible)
194 horizontal_buffer -= m_vertical_scrollbar->width();
195 horizontal_scrollbar_should_be_visible = horizontal_buffer < 0;
196 if (horizontal_scrollbar_should_be_visible)
197 vertical_buffer -= m_horizontal_scrollbar->height();
198 vertical_scrollbar_should_be_visible = vertical_buffer < 0;
199 m_horizontal_scrollbar->set_visible(horizontal_scrollbar_should_be_visible);
200 m_vertical_scrollbar->set_visible(vertical_scrollbar_should_be_visible);
201 }
202}
203
204void AbstractScrollableWidget::set_content_size(Gfx::IntSize size)
205{
206 if (m_content_size == size)
207 return;
208 m_content_size = size;
209 update_scrollbar_ranges();
210}
211
212void AbstractScrollableWidget::set_min_content_size(Gfx::IntSize min_size)
213{
214 if (m_min_content_size == min_size)
215 return;
216 m_min_content_size = min_size;
217 update_scrollbar_ranges();
218}
219
220void AbstractScrollableWidget::set_size_occupied_by_fixed_elements(Gfx::IntSize size)
221{
222 if (m_size_occupied_by_fixed_elements == size)
223 return;
224 m_size_occupied_by_fixed_elements = size;
225 update_scrollbar_ranges();
226}
227
228int AbstractScrollableWidget::height_occupied_by_banner_widget() const
229{
230 return m_banner_widget && m_banner_widget->is_visible() ? m_banner_widget->height() : 0;
231}
232
233int AbstractScrollableWidget::height_occupied_by_horizontal_scrollbar() const
234{
235 return m_horizontal_scrollbar->is_visible() ? m_horizontal_scrollbar->height() : 0;
236}
237
238int AbstractScrollableWidget::width_occupied_by_vertical_scrollbar() const
239{
240 return m_vertical_scrollbar->is_visible() ? m_vertical_scrollbar->width() : 0;
241}
242
243Margins AbstractScrollableWidget::content_margins() const
244{
245 return Frame::content_margins() + Margins { height_occupied_by_banner_widget(), width_occupied_by_vertical_scrollbar(), height_occupied_by_horizontal_scrollbar(), 0 };
246}
247
248Gfx::IntRect AbstractScrollableWidget::visible_content_rect() const
249{
250 auto inner_size = Widget::content_size();
251 Gfx::IntRect rect {
252 m_horizontal_scrollbar->value(),
253 m_vertical_scrollbar->value(),
254 min(m_content_size.width(), inner_size.width() - m_size_occupied_by_fixed_elements.width()),
255 min(m_content_size.height(), inner_size.height() - m_size_occupied_by_fixed_elements.height())
256 };
257 if (rect.is_empty())
258 return {};
259 return rect;
260}
261
262void AbstractScrollableWidget::scroll_into_view(Gfx::IntRect const& rect, Orientation orientation)
263{
264 if (orientation == Orientation::Vertical)
265 return scroll_into_view(rect, false, true);
266 return scroll_into_view(rect, true, false);
267}
268
269void AbstractScrollableWidget::scroll_into_view(Gfx::IntRect const& rect, bool scroll_horizontally, bool scroll_vertically)
270{
271 auto visible_content_rect = this->visible_content_rect();
272 if (visible_content_rect.contains(rect))
273 return;
274
275 if (scroll_vertically) {
276 if (rect.top() < visible_content_rect.top()) {
277 m_vertical_scrollbar->set_value(rect.top());
278 } else if (rect.top() > visible_content_rect.top() && rect.bottom() > visible_content_rect.bottom()) {
279 m_vertical_scrollbar->set_value(rect.bottom() - visible_content_rect.height() + 1);
280 }
281 }
282 if (scroll_horizontally) {
283 if (rect.left() < visible_content_rect.left()) {
284 m_horizontal_scrollbar->set_value(rect.left());
285 } else if (rect.left() > visible_content_rect.left() && rect.right() > visible_content_rect.right()) {
286 m_horizontal_scrollbar->set_value(rect.right() - visible_content_rect.width() + 1);
287 }
288 }
289}
290
291void AbstractScrollableWidget::set_scrollbars_enabled(bool scrollbars_enabled)
292{
293 if (m_scrollbars_enabled == scrollbars_enabled)
294 return;
295 m_scrollbars_enabled = scrollbars_enabled;
296 m_vertical_scrollbar->set_visible(m_scrollbars_enabled);
297 m_horizontal_scrollbar->set_visible(m_scrollbars_enabled);
298 m_corner_widget->set_visible(m_scrollbars_enabled);
299}
300
301void AbstractScrollableWidget::scroll_to_top()
302{
303 scroll_into_view({}, Orientation::Vertical);
304}
305
306void AbstractScrollableWidget::scroll_to_bottom()
307{
308 scroll_into_view({ 0, content_height(), 0, 0 }, Orientation::Vertical);
309}
310
311void AbstractScrollableWidget::scroll_to_right()
312{
313 scroll_into_view({ content_width(), 0, 0, 0 }, Orientation::Horizontal);
314}
315
316void AbstractScrollableWidget::set_automatic_scrolling_timer_active(bool active)
317{
318 if (active == m_active_scrolling_enabled)
319 return;
320
321 m_active_scrolling_enabled = active;
322
323 if (active) {
324 automatic_scrolling_timer_did_fire();
325 m_automatic_scrolling_timer->start();
326 } else {
327 m_automatic_scrolling_timer->stop();
328 }
329}
330
331Gfx::IntPoint AbstractScrollableWidget::automatic_scroll_delta_from_position(Gfx::IntPoint pos) const
332{
333 Gfx::IntPoint delta { 0, 0 };
334
335 if (pos.y() < m_autoscroll_threshold)
336 delta.set_y(clamp(-(m_autoscroll_threshold - pos.y()), -m_autoscroll_threshold, 0));
337 else if (pos.y() > widget_inner_rect().height() - m_autoscroll_threshold)
338 delta.set_y(clamp(m_autoscroll_threshold - (widget_inner_rect().height() - pos.y()), 0, m_autoscroll_threshold));
339
340 if (pos.x() < m_autoscroll_threshold)
341 delta.set_x(clamp(-(m_autoscroll_threshold - pos.x()), -m_autoscroll_threshold, 0));
342 else if (pos.x() > widget_inner_rect().width() - m_autoscroll_threshold)
343 delta.set_x(clamp(m_autoscroll_threshold - (widget_inner_rect().width() - pos.x()), 0, m_autoscroll_threshold));
344
345 return delta;
346}
347
348Gfx::IntRect AbstractScrollableWidget::widget_inner_rect() const
349{
350 auto rect = frame_inner_rect();
351 rect.set_width(rect.width() - width_occupied_by_vertical_scrollbar());
352 rect.set_height(rect.height() - height_occupied_by_horizontal_scrollbar() - height_occupied_by_banner_widget());
353 rect.set_top(rect.top() + height_occupied_by_banner_widget());
354 return rect;
355}
356
357Gfx::IntPoint AbstractScrollableWidget::to_content_position(Gfx::IntPoint widget_position) const
358{
359 auto content_position = widget_position;
360 content_position.translate_by(horizontal_scrollbar().value(), vertical_scrollbar().value());
361 content_position.translate_by(-frame_thickness(), -frame_thickness());
362 return content_position;
363}
364
365Gfx::IntPoint AbstractScrollableWidget::to_widget_position(Gfx::IntPoint content_position) const
366{
367 auto widget_position = content_position;
368 widget_position.translate_by(-horizontal_scrollbar().value(), -vertical_scrollbar().value());
369 widget_position.translate_by(frame_thickness(), frame_thickness());
370 return widget_position;
371}
372
373Optional<UISize> AbstractScrollableWidget::calculated_min_size() const
374{
375 auto vertical_scrollbar = m_vertical_scrollbar->effective_min_size().height().as_int();
376 auto horizontal_scrollbar = m_horizontal_scrollbar->effective_min_size().width().as_int();
377 auto banner = m_banner_widget && m_banner_widget->is_visible() ? m_banner_widget->effective_min_size().width().as_int() : 0;
378 auto max_width = max(banner, horizontal_scrollbar + corner_widget().width() + frame_thickness() * 2);
379 return { { max_width, vertical_scrollbar + corner_widget().height() + frame_thickness() * 2 + height_occupied_by_banner_widget() } };
380}
381
382}