Scrollbar.cpp 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2022, the SerenityOS developers.
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <LibCore/Timer.h>
  8. #include <LibGUI/Painter.h>
  9. #include <LibGUI/Scrollbar.h>
  10. #include <LibGfx/CharacterBitmap.h>
  11. #include <LibGfx/Palette.h>
  12. #include <LibGfx/StylePainter.h>
  13. static constexpr int ANIMATION_INTERVAL = 16; // Milliseconds
  14. static constexpr double ANIMATION_TIME = 0.18; // Seconds
  15. REGISTER_WIDGET(GUI, Scrollbar)
  16. namespace GUI {
  17. static constexpr Gfx::CharacterBitmap s_up_arrow_bitmap {
  18. " "
  19. " "
  20. " "
  21. " # "
  22. " ### "
  23. " ##### "
  24. " ####### "
  25. " "
  26. " ",
  27. 9, 9
  28. };
  29. static constexpr Gfx::CharacterBitmap s_down_arrow_bitmap {
  30. " "
  31. " "
  32. " "
  33. " ####### "
  34. " ##### "
  35. " ### "
  36. " # "
  37. " "
  38. " ",
  39. 9, 9
  40. };
  41. static constexpr Gfx::CharacterBitmap s_left_arrow_bitmap {
  42. " "
  43. " # "
  44. " ## "
  45. " ### "
  46. " #### "
  47. " ### "
  48. " ## "
  49. " # "
  50. " ",
  51. 9, 9
  52. };
  53. static constexpr Gfx::CharacterBitmap s_right_arrow_bitmap {
  54. " "
  55. " # "
  56. " ## "
  57. " ### "
  58. " #### "
  59. " ### "
  60. " ## "
  61. " # "
  62. " ",
  63. 9, 9
  64. };
  65. Scrollbar::Scrollbar(Orientation orientation)
  66. : AbstractSlider(orientation)
  67. {
  68. m_automatic_scrolling_timer = add<Core::Timer>();
  69. if (orientation == Orientation::Vertical) {
  70. set_fixed_width(16);
  71. } else {
  72. set_fixed_height(16);
  73. }
  74. m_automatic_scrolling_timer->set_interval(100);
  75. m_automatic_scrolling_timer->on_timeout = [this] {
  76. on_automatic_scrolling_timer_fired();
  77. };
  78. }
  79. Scrollbar::~Scrollbar()
  80. {
  81. }
  82. Gfx::IntRect Scrollbar::decrement_button_rect() const
  83. {
  84. return { 0, 0, button_width(), button_height() };
  85. }
  86. Gfx::IntRect Scrollbar::increment_button_rect() const
  87. {
  88. if (orientation() == Orientation::Vertical)
  89. return { 0, height() - button_height(), button_width(), button_height() };
  90. else
  91. return { width() - button_width(), 0, button_width(), button_height() };
  92. }
  93. int Scrollbar::scrubbable_range_in_pixels() const
  94. {
  95. if (orientation() == Orientation::Vertical)
  96. return height() - button_height() * 2 - visible_scrubber_size();
  97. else
  98. return width() - button_width() * 2 - visible_scrubber_size();
  99. }
  100. bool Scrollbar::has_scrubber() const
  101. {
  102. return max() != min();
  103. }
  104. void Scrollbar::set_value(int value, AllowCallback allow_callback)
  105. {
  106. m_target_value = value;
  107. if (!(m_animated_scrolling_timer.is_null()))
  108. m_animated_scrolling_timer->stop();
  109. AbstractSlider::set_value(value, allow_callback);
  110. }
  111. void Scrollbar::set_target_value(int new_target_value)
  112. {
  113. new_target_value = clamp(new_target_value, min(), max());
  114. // If we are already at or scrolling to the new target then don't touch anything
  115. if (m_target_value == new_target_value)
  116. return;
  117. m_animation_time_elapsed = 0;
  118. m_start_value = value();
  119. m_target_value = new_target_value;
  120. if (m_animated_scrolling_timer.is_null()) {
  121. m_animated_scrolling_timer = add<Core::Timer>();
  122. m_animated_scrolling_timer->set_interval(ANIMATION_INTERVAL);
  123. m_animated_scrolling_timer->on_timeout = [this]() {
  124. m_animation_time_elapsed += (double)ANIMATION_INTERVAL / 1'000; // ms -> sec
  125. update_animated_scroll();
  126. };
  127. }
  128. m_animated_scrolling_timer->start();
  129. }
  130. float Scrollbar::unclamped_scrubber_size() const
  131. {
  132. float pixel_range = length(orientation()) - button_size() * 2;
  133. float value_range = max() - min();
  134. float scrubber_size { 0 };
  135. if (value_range > 0) {
  136. // Scrubber size should be proportional to the visible portion
  137. // (page) in relation to the content (value range + page)
  138. scrubber_size = (page_step() * pixel_range) / (value_range + page_step());
  139. }
  140. return scrubber_size;
  141. }
  142. int Scrollbar::visible_scrubber_size() const
  143. {
  144. return ::max(unclamped_scrubber_size(), button_size());
  145. }
  146. Gfx::IntRect Scrollbar::scrubber_rect() const
  147. {
  148. if (!has_scrubber() || length(orientation()) <= (button_size() * 2) + visible_scrubber_size())
  149. return {};
  150. float x_or_y;
  151. if (value() == min())
  152. x_or_y = button_size();
  153. else if (value() == max())
  154. x_or_y = length(orientation()) - button_size() - visible_scrubber_size();
  155. else {
  156. float range_size = max() - min();
  157. float available = scrubbable_range_in_pixels();
  158. float step = available / range_size;
  159. x_or_y = (button_size() + (step * value()));
  160. }
  161. if (orientation() == Orientation::Vertical)
  162. return { 0, (int)x_or_y, button_width(), visible_scrubber_size() };
  163. else
  164. return { (int)x_or_y, 0, visible_scrubber_size(), button_height() };
  165. }
  166. void Scrollbar::paint_event(PaintEvent& event)
  167. {
  168. Painter painter(*this);
  169. painter.add_clip_rect(event.rect());
  170. Component hovered_component_for_painting = m_hovered_component;
  171. if (!has_scrubber() || (m_pressed_component != Component::None && m_hovered_component != m_pressed_component))
  172. hovered_component_for_painting = Component::None;
  173. painter.fill_rect_with_dither_pattern(rect(), palette().button().lightened(1.3f), palette().button());
  174. if (gutter_click_state != GutterClickState::NotPressed && has_scrubber() && hovered_component_for_painting == Component::Gutter) {
  175. VERIFY(!scrubber_rect().is_null());
  176. Gfx::IntRect rect_to_fill = rect();
  177. if (orientation() == Orientation::Vertical) {
  178. if (gutter_click_state == GutterClickState::BeforeScrubber) {
  179. rect_to_fill.set_top(decrement_button_rect().bottom());
  180. rect_to_fill.set_bottom(scrubber_rect().top());
  181. } else {
  182. VERIFY(gutter_click_state == GutterClickState::AfterScrubber);
  183. rect_to_fill.set_top(scrubber_rect().bottom());
  184. rect_to_fill.set_bottom(increment_button_rect().top());
  185. }
  186. } else {
  187. if (gutter_click_state == GutterClickState::BeforeScrubber) {
  188. rect_to_fill.set_left(decrement_button_rect().right());
  189. rect_to_fill.set_right(scrubber_rect().left());
  190. } else {
  191. VERIFY(gutter_click_state == GutterClickState::AfterScrubber);
  192. rect_to_fill.set_left(scrubber_rect().right());
  193. rect_to_fill.set_right(increment_button_rect().left());
  194. }
  195. }
  196. painter.fill_rect_with_dither_pattern(rect_to_fill, palette().button(), palette().button().lightened(0.77f));
  197. }
  198. bool decrement_pressed = (m_pressed_component == Component::DecrementButton) && (m_pressed_component == m_hovered_component);
  199. bool increment_pressed = (m_pressed_component == Component::IncrementButton) && (m_pressed_component == m_hovered_component);
  200. Gfx::StylePainter::paint_button(painter, decrement_button_rect(), palette(), Gfx::ButtonStyle::ThickCap, decrement_pressed, hovered_component_for_painting == Component::DecrementButton);
  201. Gfx::StylePainter::paint_button(painter, increment_button_rect(), palette(), Gfx::ButtonStyle::ThickCap, increment_pressed, hovered_component_for_painting == Component::IncrementButton);
  202. if (length(orientation()) > default_button_size()) {
  203. auto decrement_location = decrement_button_rect().location().translated(3, 3);
  204. if (decrement_pressed)
  205. decrement_location.translate_by(1, 1);
  206. if (!has_scrubber() || !is_enabled())
  207. painter.draw_bitmap(decrement_location.translated(1, 1), orientation() == Orientation::Vertical ? s_up_arrow_bitmap : s_left_arrow_bitmap, palette().threed_highlight());
  208. painter.draw_bitmap(decrement_location, orientation() == Orientation::Vertical ? s_up_arrow_bitmap : s_left_arrow_bitmap, (has_scrubber() && is_enabled()) ? palette().button_text() : palette().threed_shadow1());
  209. auto increment_location = increment_button_rect().location().translated(3, 3);
  210. if (increment_pressed)
  211. increment_location.translate_by(1, 1);
  212. if (!has_scrubber() || !is_enabled())
  213. painter.draw_bitmap(increment_location.translated(1, 1), orientation() == Orientation::Vertical ? s_down_arrow_bitmap : s_right_arrow_bitmap, palette().threed_highlight());
  214. painter.draw_bitmap(increment_location, orientation() == Orientation::Vertical ? s_down_arrow_bitmap : s_right_arrow_bitmap, (has_scrubber() && is_enabled()) ? palette().button_text() : palette().threed_shadow1());
  215. }
  216. if (has_scrubber() && !scrubber_rect().is_null())
  217. Gfx::StylePainter::paint_button(painter, scrubber_rect(), palette(), Gfx::ButtonStyle::ThickCap, false, hovered_component_for_painting == Component::Scrubber || m_pressed_component == Component::Scrubber);
  218. }
  219. void Scrollbar::on_automatic_scrolling_timer_fired()
  220. {
  221. if (m_pressed_component == Component::DecrementButton && component_at_position(m_last_mouse_position) == Component::DecrementButton) {
  222. decrease_slider_by_steps(1);
  223. return;
  224. }
  225. if (m_pressed_component == Component::IncrementButton && component_at_position(m_last_mouse_position) == Component::IncrementButton) {
  226. increase_slider_by_steps(1);
  227. return;
  228. }
  229. if (m_pressed_component == Component::Gutter && component_at_position(m_last_mouse_position) == Component::Gutter) {
  230. scroll_by_page(m_last_mouse_position);
  231. if (m_hovered_component != component_at_position(m_last_mouse_position)) {
  232. m_hovered_component = component_at_position(m_last_mouse_position);
  233. if (m_hovered_component != Component::Gutter)
  234. gutter_click_state = GutterClickState::NotPressed;
  235. update();
  236. }
  237. return;
  238. }
  239. gutter_click_state = GutterClickState::NotPressed;
  240. }
  241. void Scrollbar::mousedown_event(MouseEvent& event)
  242. {
  243. if (event.button() != MouseButton::Primary)
  244. return;
  245. if (!has_scrubber())
  246. return;
  247. m_last_mouse_position = event.position();
  248. m_pressed_component = component_at_position(m_last_mouse_position);
  249. if (m_pressed_component == Component::DecrementButton) {
  250. set_automatic_scrolling_active(true, Component::DecrementButton);
  251. update();
  252. return;
  253. }
  254. if (m_pressed_component == Component::IncrementButton) {
  255. set_automatic_scrolling_active(true, Component::IncrementButton);
  256. update();
  257. return;
  258. }
  259. if (event.shift()) {
  260. scroll_to_position(event.position());
  261. m_pressed_component = component_at_position(event.position());
  262. VERIFY(m_pressed_component == Component::Scrubber);
  263. }
  264. if (m_pressed_component == Component::Scrubber) {
  265. m_scrub_start_value = value();
  266. m_scrub_origin = event.position();
  267. update();
  268. return;
  269. }
  270. VERIFY(!event.shift());
  271. VERIFY(m_pressed_component == Component::Gutter);
  272. set_automatic_scrolling_active(true, Component::Gutter);
  273. update();
  274. }
  275. void Scrollbar::mouseup_event(MouseEvent& event)
  276. {
  277. if (event.button() != MouseButton::Primary)
  278. return;
  279. set_automatic_scrolling_active(false, Component::None);
  280. update();
  281. }
  282. void Scrollbar::mousewheel_event(MouseEvent& event)
  283. {
  284. if (!is_scrollable())
  285. return;
  286. increase_slider_by_steps(event.wheel_delta_y());
  287. Widget::mousewheel_event(event);
  288. }
  289. void Scrollbar::set_automatic_scrolling_active(bool active, Component pressed_component)
  290. {
  291. m_pressed_component = pressed_component;
  292. if (m_pressed_component == Component::Gutter)
  293. m_automatic_scrolling_timer->set_interval(200);
  294. else
  295. m_automatic_scrolling_timer->set_interval(100);
  296. if (active) {
  297. on_automatic_scrolling_timer_fired();
  298. m_automatic_scrolling_timer->start();
  299. } else {
  300. m_automatic_scrolling_timer->stop();
  301. gutter_click_state = GutterClickState::NotPressed;
  302. }
  303. }
  304. void Scrollbar::scroll_by_page(const Gfx::IntPoint& click_position)
  305. {
  306. float range_size = max() - min();
  307. float available = scrubbable_range_in_pixels();
  308. float rel_scrubber_size = unclamped_scrubber_size() / available;
  309. float page_increment = range_size * rel_scrubber_size;
  310. if (click_position.primary_offset_for_orientation(orientation()) < scrubber_rect().primary_offset_for_orientation(orientation())) {
  311. gutter_click_state = GutterClickState::BeforeScrubber;
  312. decrease_slider_by(page_increment);
  313. } else {
  314. gutter_click_state = GutterClickState::AfterScrubber;
  315. increase_slider_by(page_increment);
  316. }
  317. }
  318. void Scrollbar::scroll_to_position(const Gfx::IntPoint& click_position)
  319. {
  320. float range_size = max() - min();
  321. float available = scrubbable_range_in_pixels();
  322. float x_or_y = ::max(0, click_position.primary_offset_for_orientation(orientation()) - button_width() - button_width() / 2);
  323. float rel_x_or_y = x_or_y / available;
  324. set_target_value(min() + rel_x_or_y * range_size);
  325. }
  326. Scrollbar::Component Scrollbar::component_at_position(const Gfx::IntPoint& position)
  327. {
  328. if (scrubber_rect().contains(position))
  329. return Component::Scrubber;
  330. if (decrement_button_rect().contains(position))
  331. return Component::DecrementButton;
  332. if (increment_button_rect().contains(position))
  333. return Component::IncrementButton;
  334. if (rect().contains(position))
  335. return Component::Gutter;
  336. return Component::None;
  337. }
  338. void Scrollbar::mousemove_event(MouseEvent& event)
  339. {
  340. if (!is_scrollable())
  341. return;
  342. m_last_mouse_position = event.position();
  343. auto old_hovered_component = m_hovered_component;
  344. m_hovered_component = component_at_position(m_last_mouse_position);
  345. if (old_hovered_component != m_hovered_component) {
  346. if (is_enabled())
  347. update();
  348. }
  349. if (m_pressed_component != Component::Scrubber)
  350. return;
  351. float delta = orientation() == Orientation::Vertical ? (event.y() - m_scrub_origin.y()) : (event.x() - m_scrub_origin.x());
  352. float scrubbable_range = scrubbable_range_in_pixels();
  353. float value_steps_per_scrubbed_pixel = (max() - min()) / scrubbable_range;
  354. float new_value = m_scrub_start_value + (value_steps_per_scrubbed_pixel * delta);
  355. set_value(new_value);
  356. }
  357. void Scrollbar::leave_event(Core::Event&)
  358. {
  359. if (m_hovered_component != Component::None) {
  360. m_hovered_component = Component::None;
  361. if (is_enabled())
  362. update();
  363. }
  364. }
  365. void Scrollbar::change_event(Event& event)
  366. {
  367. if (event.type() == Event::Type::EnabledChange) {
  368. if (!is_enabled())
  369. set_automatic_scrolling_active(false, Component::None);
  370. }
  371. return Widget::change_event(event);
  372. }
  373. void Scrollbar::update_animated_scroll()
  374. {
  375. if (value() == m_target_value) {
  376. m_animated_scrolling_timer->stop();
  377. return;
  378. }
  379. double time_percent = m_animation_time_elapsed / ANIMATION_TIME;
  380. double ease_percent = 1.0 - pow(1.0 - time_percent, 5.0); // Ease out quint
  381. double initial_distance = m_target_value - m_start_value;
  382. double new_distance = initial_distance * ease_percent;
  383. int new_value = m_start_value + (int)round(new_distance);
  384. AbstractSlider::set_value(new_value);
  385. }
  386. }