godot/scene/gui/scroll_bar.cpp

657 lines
19 KiB
C++
Raw Normal View History

2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* scroll_bar.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 01:10:30 +00:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2014-02-10 01:10:30 +00:00
#include "scroll_bar.h"
2017-08-27 19:07:15 +00:00
#include "core/os/keyboard.h"
#include "core/os/os.h"
#include "core/string/print_string.h"
#include "scene/main/window.h"
2017-08-27 19:07:15 +00:00
bool ScrollBar::focus_by_default = false;
2014-02-10 01:10:30 +00:00
void ScrollBar::set_can_focus_by_default(bool p_can_focus) {
focus_by_default = p_can_focus;
2014-02-10 01:10:30 +00:00
}
void ScrollBar::gui_input(const Ref<InputEvent> &p_event) {
2021-04-05 06:52:21 +00:00
ERR_FAIL_COND(p_event.is_null());
Ref<InputEventMouseMotion> m = p_event;
if (!m.is_valid() || drag.active) {
emit_signal(SNAME("scrolling"));
}
Ref<InputEventMouseButton> b = p_event;
2016-03-08 23:00:52 +00:00
if (b.is_valid()) {
accept_event();
2016-03-08 23:00:52 +00:00
2021-08-13 21:31:57 +00:00
if (b->get_button_index() == MouseButton::WHEEL_DOWN && b->is_pressed()) {
set_value(get_value() + get_page() / 4.0);
accept_event();
}
2016-03-08 23:00:52 +00:00
2021-08-13 21:31:57 +00:00
if (b->get_button_index() == MouseButton::WHEEL_UP && b->is_pressed()) {
set_value(get_value() - get_page() / 4.0);
accept_event();
}
2014-02-10 01:10:30 +00:00
2021-08-13 21:31:57 +00:00
if (b->get_button_index() != MouseButton::LEFT) {
return;
}
2016-03-08 23:00:52 +00:00
if (b->is_pressed()) {
double ofs = orientation == VERTICAL ? b->get_position().y : b->get_position().x;
Ref<Texture2D> decr = theme_cache.decrement_icon;
Ref<Texture2D> incr = theme_cache.increment_icon;
2016-03-08 23:00:52 +00:00
double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width();
double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width();
double grabber_ofs = get_grabber_offset();
double grabber_size = get_grabber_size();
double total = orientation == VERTICAL ? get_size().height : get_size().width;
2016-03-08 23:00:52 +00:00
if (ofs < decr_size) {
decr_active = true;
set_value(get_value() - (custom_step >= 0 ? custom_step : get_step()));
queue_redraw();
return;
}
2016-03-08 23:00:52 +00:00
if (ofs > total - incr_size) {
incr_active = true;
set_value(get_value() + (custom_step >= 0 ? custom_step : get_step()));
queue_redraw();
return;
}
2016-03-08 23:00:52 +00:00
ofs -= decr_size;
2016-03-08 23:00:52 +00:00
if (ofs < grabber_ofs) {
2017-08-19 14:23:45 +00:00
if (scrolling) {
target_scroll = CLAMP(target_scroll - get_page(), get_min(), get_max() - get_page());
2017-08-19 14:23:45 +00:00
} else {
target_scroll = CLAMP(get_value() - get_page(), get_min(), get_max() - get_page());
2017-08-19 14:23:45 +00:00
}
if (smooth_scroll_enabled) {
scrolling = true;
set_physics_process_internal(true);
2017-08-19 14:23:45 +00:00
} else {
set_value(target_scroll);
}
return;
}
2016-03-08 23:00:52 +00:00
ofs -= grabber_ofs;
2016-03-08 23:00:52 +00:00
if (ofs < grabber_size) {
drag.active = true;
drag.pos_at_click = grabber_ofs + ofs;
drag.value_at_click = get_as_ratio();
queue_redraw();
2014-02-10 01:10:30 +00:00
} else {
2017-08-19 14:23:45 +00:00
if (scrolling) {
target_scroll = CLAMP(target_scroll + get_page(), get_min(), get_max() - get_page());
2017-08-19 14:23:45 +00:00
} else {
target_scroll = CLAMP(get_value() + get_page(), get_min(), get_max() - get_page());
2017-08-19 14:23:45 +00:00
}
2016-03-08 23:00:52 +00:00
2017-08-19 14:23:45 +00:00
if (smooth_scroll_enabled) {
scrolling = true;
set_physics_process_internal(true);
2017-08-19 14:23:45 +00:00
} else {
set_value(target_scroll);
}
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
} else {
incr_active = false;
decr_active = false;
drag.active = false;
queue_redraw();
}
}
2014-02-10 01:10:30 +00:00
if (m.is_valid()) {
accept_event();
2016-03-08 23:00:52 +00:00
if (drag.active) {
double ofs = orientation == VERTICAL ? m->get_position().y : m->get_position().x;
Ref<Texture2D> decr = theme_cache.decrement_icon;
2014-02-10 01:10:30 +00:00
double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width();
ofs -= decr_size;
2016-03-08 23:00:52 +00:00
double diff = (ofs - drag.pos_at_click) / get_area_size();
2016-03-08 23:00:52 +00:00
set_as_ratio(drag.value_at_click + diff);
} else {
double ofs = orientation == VERTICAL ? m->get_position().y : m->get_position().x;
Ref<Texture2D> decr = theme_cache.decrement_icon;
Ref<Texture2D> incr = theme_cache.increment_icon;
2016-03-08 23:00:52 +00:00
double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width();
double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width();
double total = orientation == VERTICAL ? get_size().height : get_size().width;
2016-03-08 23:00:52 +00:00
HighlightStatus new_hilite;
2016-03-08 23:00:52 +00:00
if (ofs < decr_size) {
new_hilite = HIGHLIGHT_DECR;
2016-03-08 23:00:52 +00:00
} else if (ofs > total - incr_size) {
new_hilite = HIGHLIGHT_INCR;
2016-03-08 23:00:52 +00:00
} else {
new_hilite = HIGHLIGHT_RANGE;
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
if (new_hilite != highlight) {
highlight = new_hilite;
queue_redraw();
}
}
}
2016-03-08 23:00:52 +00:00
if (p_event->is_pressed()) {
if (p_event->is_action("ui_left")) {
if (orientation != HORIZONTAL) {
return;
}
set_value(get_value() - (custom_step >= 0 ? custom_step : get_step()));
2016-03-08 23:00:52 +00:00
} else if (p_event->is_action("ui_right")) {
if (orientation != HORIZONTAL) {
return;
}
set_value(get_value() + (custom_step >= 0 ? custom_step : get_step()));
2016-03-08 23:00:52 +00:00
} else if (p_event->is_action("ui_up")) {
if (orientation != VERTICAL) {
return;
}
2016-03-08 23:00:52 +00:00
set_value(get_value() - (custom_step >= 0 ? custom_step : get_step()));
2016-03-08 23:00:52 +00:00
} else if (p_event->is_action("ui_down")) {
if (orientation != VERTICAL) {
return;
}
set_value(get_value() + (custom_step >= 0 ? custom_step : get_step()));
2016-03-08 23:00:52 +00:00
} else if (p_event->is_action("ui_home")) {
set_value(get_min());
} else if (p_event->is_action("ui_end")) {
set_value(get_max());
2016-03-08 23:00:52 +00:00
}
2014-02-10 01:10:30 +00:00
}
}
void ScrollBar::_update_theme_item_cache() {
Range::_update_theme_item_cache();
theme_cache.scroll_style = get_theme_stylebox(SNAME("scroll"));
theme_cache.scroll_focus_style = get_theme_stylebox(SNAME("scroll_focus"));
theme_cache.scroll_offset_style = get_theme_stylebox(SNAME("hscroll"));
theme_cache.grabber_style = get_theme_stylebox(SNAME("grabber"));
theme_cache.grabber_hl_style = get_theme_stylebox(SNAME("grabber_highlight"));
theme_cache.grabber_pressed_style = get_theme_stylebox(SNAME("grabber_pressed"));
theme_cache.increment_icon = get_theme_icon(SNAME("increment"));
theme_cache.increment_hl_icon = get_theme_icon(SNAME("increment_highlight"));
theme_cache.increment_pressed_icon = get_theme_icon(SNAME("increment_pressed"));
theme_cache.decrement_icon = get_theme_icon(SNAME("decrement"));
theme_cache.decrement_hl_icon = get_theme_icon(SNAME("decrement_highlight"));
theme_cache.decrement_pressed_icon = get_theme_icon(SNAME("decrement_pressed"));
}
2014-02-10 01:10:30 +00:00
void ScrollBar::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_DRAW: {
RID ci = get_canvas_item();
2016-03-08 23:00:52 +00:00
Ref<Texture2D> decr, incr;
if (decr_active) {
decr = theme_cache.decrement_pressed_icon;
} else if (highlight == HIGHLIGHT_DECR) {
decr = theme_cache.decrement_hl_icon;
} else {
decr = theme_cache.decrement_icon;
}
if (incr_active) {
incr = theme_cache.increment_pressed_icon;
} else if (highlight == HIGHLIGHT_INCR) {
incr = theme_cache.increment_hl_icon;
} else {
incr = theme_cache.increment_icon;
}
Ref<StyleBox> bg = has_focus() ? theme_cache.scroll_focus_style : theme_cache.scroll_style;
2016-03-08 23:00:52 +00:00
Ref<StyleBox> grabber;
if (drag.active) {
grabber = theme_cache.grabber_pressed_style;
} else if (highlight == HIGHLIGHT_RANGE) {
grabber = theme_cache.grabber_hl_style;
} else {
grabber = theme_cache.grabber_style;
}
2016-03-08 23:00:52 +00:00
Point2 ofs;
2014-02-10 01:10:30 +00:00
decr->draw(ci, Point2());
2014-02-10 01:10:30 +00:00
if (orientation == HORIZONTAL) {
ofs.x += decr->get_width();
} else {
ofs.y += decr->get_height();
}
2014-02-10 01:10:30 +00:00
Size2 area = get_size();
2014-02-10 01:10:30 +00:00
if (orientation == HORIZONTAL) {
area.width -= incr->get_width() + decr->get_width();
} else {
area.height -= incr->get_height() + decr->get_height();
}
2016-03-08 23:00:52 +00:00
bg->draw(ci, Rect2(ofs, area));
2014-02-10 01:10:30 +00:00
if (orientation == HORIZONTAL) {
ofs.width += area.width;
} else {
ofs.height += area.height;
}
2016-03-08 23:00:52 +00:00
incr->draw(ci, ofs);
Rect2 grabber_rect;
2016-03-08 23:00:52 +00:00
if (orientation == HORIZONTAL) {
grabber_rect.size.width = get_grabber_size();
grabber_rect.size.height = get_size().height;
grabber_rect.position.y = 0;
grabber_rect.position.x = get_grabber_offset() + decr->get_width() + bg->get_margin(SIDE_LEFT);
} else {
grabber_rect.size.width = get_size().width;
grabber_rect.size.height = get_grabber_size();
grabber_rect.position.y = get_grabber_offset() + decr->get_height() + bg->get_margin(SIDE_TOP);
grabber_rect.position.x = 0;
}
2016-03-08 23:00:52 +00:00
grabber->draw(ci, grabber_rect);
} break;
case NOTIFICATION_ENTER_TREE: {
if (has_node(drag_node_path)) {
Node *n = get_node(drag_node_path);
drag_node = Object::cast_to<Control>(n);
}
if (drag_node) {
drag_node->connect("gui_input", callable_mp(this, &ScrollBar::_drag_node_input));
drag_node->connect("tree_exiting", callable_mp(this, &ScrollBar::_drag_node_exit), CONNECT_ONESHOT);
}
} break;
case NOTIFICATION_EXIT_TREE: {
if (drag_node) {
drag_node->disconnect("gui_input", callable_mp(this, &ScrollBar::_drag_node_input));
drag_node->disconnect("tree_exiting", callable_mp(this, &ScrollBar::_drag_node_exit));
}
2017-08-19 14:23:45 +00:00
drag_node = nullptr;
} break;
case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
if (scrolling) {
if (get_value() != target_scroll) {
double target = target_scroll - get_value();
double dist = sqrt(target * target);
double vel = ((target / dist) * 500) * get_physics_process_delta_time();
if (Math::abs(vel) >= dist) {
set_value(target_scroll);
scrolling = false;
set_physics_process_internal(false);
} else {
set_value(get_value() + vel);
}
} else {
scrolling = false;
set_physics_process_internal(false);
2017-08-19 14:23:45 +00:00
}
} else if (drag_node_touching) {
if (drag_node_touching_deaccel) {
Vector2 pos = Vector2(orientation == HORIZONTAL ? get_value() : 0, orientation == VERTICAL ? get_value() : 0);
pos += drag_node_speed * get_physics_process_delta_time();
bool turnoff = false;
if (orientation == HORIZONTAL) {
if (pos.x < 0) {
pos.x = 0;
turnoff = true;
}
if (pos.x > (get_max() - get_page())) {
pos.x = get_max() - get_page();
turnoff = true;
}
set_value(pos.x);
float sgn_x = drag_node_speed.x < 0 ? -1 : 1;
float val_x = Math::abs(drag_node_speed.x);
val_x -= 1000 * get_physics_process_delta_time();
if (val_x < 0) {
turnoff = true;
}
drag_node_speed.x = sgn_x * val_x;
} else {
if (pos.y < 0) {
pos.y = 0;
turnoff = true;
}
if (pos.y > (get_max() - get_page())) {
pos.y = get_max() - get_page();
turnoff = true;
}
set_value(pos.y);
float sgn_y = drag_node_speed.y < 0 ? -1 : 1;
float val_y = Math::abs(drag_node_speed.y);
val_y -= 1000 * get_physics_process_delta_time();
if (val_y < 0) {
turnoff = true;
}
drag_node_speed.y = sgn_y * val_y;
}
if (turnoff) {
set_physics_process_internal(false);
drag_node_touching = false;
drag_node_touching_deaccel = false;
}
} else {
if (time_since_motion == 0 || time_since_motion > 0.1) {
Vector2 diff = drag_node_accum - last_drag_node_accum;
last_drag_node_accum = drag_node_accum;
drag_node_speed = diff / get_physics_process_delta_time();
}
time_since_motion += get_physics_process_delta_time();
}
}
} break;
case NOTIFICATION_MOUSE_EXIT: {
highlight = HIGHLIGHT_NONE;
queue_redraw();
} break;
2014-02-10 01:10:30 +00:00
}
}
double ScrollBar::get_grabber_min_size() const {
Ref<StyleBox> grabber = theme_cache.grabber_style;
Size2 gminsize = grabber->get_minimum_size() + grabber->get_center_size();
return (orientation == VERTICAL) ? gminsize.height : gminsize.width;
2014-02-10 01:10:30 +00:00
}
double ScrollBar::get_grabber_size() const {
float range = get_max() - get_min();
if (range <= 0) {
2014-02-10 01:10:30 +00:00
return 0;
}
2016-03-08 23:00:52 +00:00
float page = (get_page() > 0) ? get_page() : 0;
double area_size = get_area_size();
2014-02-10 01:10:30 +00:00
double grabber_size = page / range * area_size;
return grabber_size + get_grabber_min_size();
2016-03-08 23:00:52 +00:00
}
2014-02-10 01:10:30 +00:00
double ScrollBar::get_area_size() const {
2019-06-20 14:59:48 +00:00
switch (orientation) {
case VERTICAL: {
double area = get_size().height;
area -= theme_cache.scroll_style->get_minimum_size().height;
area -= theme_cache.increment_icon->get_height();
area -= theme_cache.decrement_icon->get_height();
2019-06-20 14:59:48 +00:00
area -= get_grabber_min_size();
return area;
} break;
case HORIZONTAL: {
double area = get_size().width;
area -= theme_cache.scroll_style->get_minimum_size().width;
area -= theme_cache.increment_icon->get_width();
area -= theme_cache.decrement_icon->get_width();
2019-06-20 14:59:48 +00:00
area -= get_grabber_min_size();
return area;
} break;
default: {
return 0.0;
}
2014-02-10 01:10:30 +00:00
}
}
double ScrollBar::get_area_offset() const {
double ofs = 0.0;
2016-03-08 23:00:52 +00:00
if (orientation == VERTICAL) {
ofs += theme_cache.scroll_offset_style->get_margin(SIDE_TOP);
ofs += theme_cache.decrement_icon->get_height();
2016-03-08 23:00:52 +00:00
}
if (orientation == HORIZONTAL) {
ofs += theme_cache.scroll_offset_style->get_margin(SIDE_LEFT);
ofs += theme_cache.decrement_icon->get_width();
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
return ofs;
2014-02-10 01:10:30 +00:00
}
double ScrollBar::get_grabber_offset() const {
return (get_area_size()) * get_as_ratio();
2014-02-10 01:10:30 +00:00
}
Size2 ScrollBar::get_minimum_size() const {
Ref<Texture2D> incr = theme_cache.increment_icon;
Ref<Texture2D> decr = theme_cache.decrement_icon;
Ref<StyleBox> bg = theme_cache.scroll_style;
2014-02-10 01:10:30 +00:00
Size2 minsize;
2016-03-08 23:00:52 +00:00
if (orientation == VERTICAL) {
minsize.width = MAX(incr->get_size().width, (bg->get_minimum_size() + bg->get_center_size()).width);
minsize.height += incr->get_size().height;
minsize.height += decr->get_size().height;
minsize.height += bg->get_minimum_size().height;
minsize.height += get_grabber_min_size();
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
if (orientation == HORIZONTAL) {
minsize.height = MAX(incr->get_size().height, (bg->get_center_size() + bg->get_minimum_size()).height);
minsize.width += incr->get_size().width;
minsize.width += decr->get_size().width;
minsize.width += bg->get_minimum_size().width;
minsize.width += get_grabber_min_size();
2014-02-10 01:10:30 +00:00
}
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
return minsize;
}
void ScrollBar::set_custom_step(float p_custom_step) {
custom_step = p_custom_step;
2014-02-10 01:10:30 +00:00
}
float ScrollBar::get_custom_step() const {
return custom_step;
}
void ScrollBar::_drag_node_exit() {
if (drag_node) {
drag_node->disconnect("gui_input", callable_mp(this, &ScrollBar::_drag_node_input));
}
2020-04-01 23:20:12 +00:00
drag_node = nullptr;
}
void ScrollBar::_drag_node_input(const Ref<InputEvent> &p_input) {
if (!drag_node_enabled) {
return;
}
Ref<InputEventMouseButton> mb = p_input;
if (mb.is_valid()) {
2021-08-13 21:31:57 +00:00
if (mb->get_button_index() != MouseButton::LEFT) {
return;
}
if (mb->is_pressed()) {
drag_node_speed = Vector2();
drag_node_accum = Vector2();
last_drag_node_accum = Vector2();
drag_node_from = Vector2(orientation == HORIZONTAL ? get_value() : 0, orientation == VERTICAL ? get_value() : 0);
drag_node_touching = DisplayServer::get_singleton()->screen_is_touchscreen(DisplayServer::get_singleton()->window_get_current_screen(get_viewport()->get_window_id()));
drag_node_touching_deaccel = false;
time_since_motion = 0;
if (drag_node_touching) {
set_physics_process_internal(true);
time_since_motion = 0;
}
} else {
if (drag_node_touching) {
if (drag_node_speed == Vector2()) {
drag_node_touching_deaccel = false;
drag_node_touching = false;
set_physics_process_internal(false);
} else {
drag_node_touching_deaccel = true;
}
}
}
}
Ref<InputEventMouseMotion> mm = p_input;
if (mm.is_valid()) {
if (drag_node_touching && !drag_node_touching_deaccel) {
2021-09-23 14:58:43 +00:00
Vector2 motion = mm->get_relative();
drag_node_accum -= motion;
Vector2 diff = drag_node_from + drag_node_accum;
if (orientation == HORIZONTAL) {
set_value(diff.x);
}
if (orientation == VERTICAL) {
set_value(diff.y);
}
time_since_motion = 0;
}
}
}
void ScrollBar::set_drag_node(const NodePath &p_path) {
if (is_inside_tree()) {
if (drag_node) {
drag_node->disconnect("gui_input", callable_mp(this, &ScrollBar::_drag_node_input));
drag_node->disconnect("tree_exiting", callable_mp(this, &ScrollBar::_drag_node_exit));
}
}
2020-04-01 23:20:12 +00:00
drag_node = nullptr;
drag_node_path = p_path;
if (is_inside_tree()) {
if (has_node(p_path)) {
Node *n = get_node(p_path);
drag_node = Object::cast_to<Control>(n);
}
if (drag_node) {
drag_node->connect("gui_input", callable_mp(this, &ScrollBar::_drag_node_input));
drag_node->connect("tree_exiting", callable_mp(this, &ScrollBar::_drag_node_exit), CONNECT_ONESHOT);
}
}
}
NodePath ScrollBar::get_drag_node() const {
return drag_node_path;
}
void ScrollBar::set_drag_node_enabled(bool p_enable) {
drag_node_enabled = p_enable;
}
2017-08-19 14:23:45 +00:00
void ScrollBar::set_smooth_scroll_enabled(bool p_enable) {
smooth_scroll_enabled = p_enable;
}
bool ScrollBar::is_smooth_scroll_enabled() const {
return smooth_scroll_enabled;
}
2014-02-10 01:10:30 +00:00
void ScrollBar::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_custom_step", "step"), &ScrollBar::set_custom_step);
ClassDB::bind_method(D_METHOD("get_custom_step"), &ScrollBar::get_custom_step);
2014-02-10 01:10:30 +00:00
ADD_SIGNAL(MethodInfo("scrolling"));
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "custom_step", PROPERTY_HINT_RANGE, "-1,4096,suffix:px"), "set_custom_step", "get_custom_step");
2014-02-10 01:10:30 +00:00
}
ScrollBar::ScrollBar(Orientation p_orientation) {
orientation = p_orientation;
2017-08-19 14:23:45 +00:00
if (focus_by_default) {
set_focus_mode(FOCUS_ALL);
}
set_step(0);
2014-02-10 01:10:30 +00:00
}
ScrollBar::~ScrollBar() {
2014-02-10 01:10:30 +00:00
}