mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-23 07:43:01 +01:00
Code Issues Releases Wiki Activity

Use (const) references to scrolls where possible

Browse Source
This commit is contained in:
Hielke Morsink
2021-10-01 15:16:17 +02:00
parent 6de1868ad8
commit 5b9b52c028
5 changed files with 171 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
src/openrct2-ui/input/MouseInput.cpp
View File

@@ -195,26 +195,26 @@ static void InputScrollDragContinue(const ScreenCoordsXY& screenCoords, rct_wind
uint8_t scrollIndex = _dragScrollIndex;
const auto& widget = w->widgets[widgetIndex];
rct_scroll* scroll = &w->scrolls[scrollIndex];
auto& scroll = w->scrolls[scrollIndex];
ScreenCoordsXY differentialCoords = screenCoords - gInputDragLast;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
{
int16_t size = widget.width() - 1;
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
size -= 11;
size = std::max(0, scroll->h_right - size);
scroll->h_left = std::min<uint16_t>(std::max(0, scroll->h_left + differentialCoords.x), size);
size = std::max(0, scroll.h_right - size);
scroll.h_left = std::min<uint16_t>(std::max(0, scroll.h_left + differentialCoords.x), size);
}
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
{
int16_t size = widget.height() - 1;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
size -= 11;
size = std::max(0, scroll->v_bottom - size);
scroll->v_top = std::min<uint16_t>(std::max(0, scroll->v_top + differentialCoords.y), size);
size = std::max(0, scroll.v_bottom - size);
scroll.v_top = std::min<uint16_t>(std::max(0, scroll.v_top + differentialCoords.y), size);
}
WidgetScrollUpdateThumbs(w, widgetIndex);
@@ -627,43 +627,43 @@ static void InputScrollBegin(rct_window* w, rct_widgetindex widgetIndex, const S
}
const auto& widg = w->widgets[widgetIndex];
rct_scroll* scroll = &w->scrolls[scroll_id];
auto& scroll = w->scrolls[scroll_id];
int32_t widget_width = widg.width() - 1;
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
widget_width -= SCROLLBAR_WIDTH + 1;
int32_t widget_content_width = std::max(scroll->h_right - widget_width, 0);
int32_t widget_content_width = std::max(scroll.h_right - widget_width, 0);
int32_t widget_height = widg.bottom - widg.top - 1;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
widget_height -= SCROLLBAR_WIDTH + 1;
int32_t widget_content_height = std::max(scroll->v_bottom - widget_height, 0);
int32_t widget_content_height = std::max(scroll.v_bottom - widget_height, 0);
switch (scroll_area)
{
case SCROLL_PART_HSCROLLBAR_LEFT:
scroll->h_left = std::max(scroll->h_left - 3, 0);
scroll.h_left = std::max(scroll.h_left - 3, 0);
break;
case SCROLL_PART_HSCROLLBAR_RIGHT:
scroll->h_left = std::min(scroll->h_left + 3, widget_content_width);
scroll.h_left = std::min(scroll.h_left + 3, widget_content_width);
break;
case SCROLL_PART_HSCROLLBAR_LEFT_TROUGH:
scroll->h_left = std::max(scroll->h_left - widget_width, 0);
scroll.h_left = std::max(scroll.h_left - widget_width, 0);
break;
case SCROLL_PART_HSCROLLBAR_RIGHT_TROUGH:
scroll->h_left = std::min(scroll->h_left + widget_width, widget_content_width);
scroll.h_left = std::min(scroll.h_left + widget_width, widget_content_width);
break;
case SCROLL_PART_VSCROLLBAR_TOP:
scroll->v_top = std::max(scroll->v_top - 3, 0);
scroll.v_top = std::max(scroll.v_top - 3, 0);
break;
case SCROLL_PART_VSCROLLBAR_BOTTOM:
scroll->v_top = std::min(scroll->v_top + 3, widget_content_height);
scroll.v_top = std::min(scroll.v_top + 3, widget_content_height);
break;
case SCROLL_PART_VSCROLLBAR_TOP_TROUGH:
scroll->v_top = std::max(scroll->v_top - widget_height, 0);
scroll.v_top = std::max(scroll.v_top - widget_height, 0);
break;
case SCROLL_PART_VSCROLLBAR_BOTTOM_TROUGH:
scroll->v_top = std::min(scroll->v_top + widget_height, widget_content_height);
scroll.v_top = std::min(scroll.v_top + widget_height, widget_content_height);
break;
default:
break;
@@ -744,32 +744,33 @@ static void InputScrollEnd()
static void InputScrollPartUpdateHThumb(rct_window* w, rct_widgetindex widgetIndex, int32_t x, int32_t scroll_id)
{
const auto& widget = w->widgets[widgetIndex];
auto& scroll = w->scrolls[scroll_id];
if (window_find_by_number(w->classification, w->number) != nullptr)
{
int32_t newLeft;
newLeft = w->scrolls[scroll_id].h_right;
newLeft = scroll.h_right;
newLeft *= x;
x = widget.width() - 21;
if (w->scrolls[scroll_id].flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
x -= SCROLLBAR_WIDTH + 1;
newLeft /= x;
x = newLeft;
w->scrolls[scroll_id].flags |= HSCROLLBAR_THUMB_PRESSED;
newLeft = w->scrolls[scroll_id].h_left;
scroll.flags |= HSCROLLBAR_THUMB_PRESSED;
newLeft = scroll.h_left;
newLeft += x;
if (newLeft < 0)
newLeft = 0;
x = widget.width() - 1;
if (w->scrolls[scroll_id].flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
x -= SCROLLBAR_WIDTH + 1;
x *= -1;
x += w->scrolls[scroll_id].h_right;
x += scroll.h_right;
if (x < 0)
x = 0;
if (newLeft > x)
newLeft = x;
w->scrolls[scroll_id].h_left = newLeft;
scroll.h_left = newLeft;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}
@@ -783,32 +784,33 @@ static void InputScrollPartUpdateVThumb(rct_window* w, rct_widgetindex widgetInd
{
assert(w != nullptr);
const auto& widget = w->widgets[widgetIndex];
auto& scroll = w->scrolls[scroll_id];
if (window_find_by_number(w->classification, w->number) != nullptr)
{
int32_t newTop;
newTop = w->scrolls[scroll_id].v_bottom;
newTop = scroll.v_bottom;
newTop *= y;
y = widget.height() - 21;
if (w->scrolls[scroll_id].flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
y -= SCROLLBAR_WIDTH + 1;
newTop /= y;
y = newTop;
w->scrolls[scroll_id].flags |= VSCROLLBAR_THUMB_PRESSED;
newTop = w->scrolls[scroll_id].v_top;
scroll.flags |= VSCROLLBAR_THUMB_PRESSED;
newTop = scroll.v_top;
newTop += y;
if (newTop < 0)
newTop = 0;
y = widget.height() - 1;
if (w->scrolls[scroll_id].flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
y -= SCROLLBAR_WIDTH + 1;
y *= -1;
y += w->scrolls[scroll_id].v_bottom;
y += scroll.v_bottom;
if (y < 0)
y = 0;
if (newTop > y)
newTop = y;
w->scrolls[scroll_id].v_top = newTop;
scroll.v_top = newTop;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}
@@ -823,9 +825,10 @@ static void InputScrollPartUpdateHLeft(rct_window* w, rct_widgetindex widgetInde
assert(w != nullptr);
if (window_find_by_number(w->classification, w->number) != nullptr)
{
w->scrolls[scroll_id].flags |= HSCROLLBAR_LEFT_PRESSED;
if (w->scrolls[scroll_id].h_left >= 3)
w->scrolls[scroll_id].h_left -= 3;
auto& scroll = w->scrolls[scroll_id];
scroll.flags |= HSCROLLBAR_LEFT_PRESSED;
if (scroll.h_left >= 3)
scroll.h_left -= 3;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}
@@ -841,17 +844,18 @@ static void InputScrollPartUpdateHRight(rct_window* w, rct_widgetindex widgetInd
const auto& widget = w->widgets[widgetIndex];
if (window_find_by_number(w->classification, w->number) != nullptr)
{
w->scrolls[scroll_id].flags |= HSCROLLBAR_RIGHT_PRESSED;
w->scrolls[scroll_id].h_left += 3;
auto& scroll = w->scrolls[scroll_id];
scroll.flags |= HSCROLLBAR_RIGHT_PRESSED;
scroll.h_left += 3;
int32_t newLeft = widget.width() - 1;
if (w->scrolls[scroll_id].flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
newLeft -= SCROLLBAR_WIDTH + 1;
newLeft *= -1;
newLeft += w->scrolls[scroll_id].h_right;
newLeft += scroll.h_right;
if (newLeft < 0)
newLeft = 0;
if (w->scrolls[scroll_id].h_left > newLeft)
w->scrolls[scroll_id].h_left = newLeft;
if (scroll.h_left > newLeft)
scroll.h_left = newLeft;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}
@@ -866,9 +870,10 @@ static void InputScrollPartUpdateVTop(rct_window* w, rct_widgetindex widgetIndex
assert(w != nullptr);
if (window_find_by_number(w->classification, w->number) != nullptr)
{
w->scrolls[scroll_id].flags |= VSCROLLBAR_UP_PRESSED;
if (w->scrolls[scroll_id].v_top >= 3)
w->scrolls[scroll_id].v_top -= 3;
auto& scroll = w->scrolls[scroll_id];
scroll.flags |= VSCROLLBAR_UP_PRESSED;
if (scroll.v_top >= 3)
scroll.v_top -= 3;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}
@@ -884,17 +889,18 @@ static void InputScrollPartUpdateVBottom(rct_window* w, rct_widgetindex widgetIn
const auto& widget = w->widgets[widgetIndex];
if (window_find_by_number(w->classification, w->number) != nullptr)
{
w->scrolls[scroll_id].flags |= VSCROLLBAR_DOWN_PRESSED;
w->scrolls[scroll_id].v_top += 3;
auto& scroll = w->scrolls[scroll_id];
scroll.flags |= VSCROLLBAR_DOWN_PRESSED;
scroll.v_top += 3;
int32_t newTop = widget.height() - 1;
if (w->scrolls[scroll_id].flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
newTop -= SCROLLBAR_WIDTH + 1;
newTop *= -1;
newTop += w->scrolls[scroll_id].v_bottom;
newTop += scroll.v_bottom;
if (newTop < 0)
newTop = 0;
if (w->scrolls[scroll_id].v_top > newTop)
w->scrolls[scroll_id].v_top = newTop;
if (scroll.v_top > newTop)
scroll.v_top = newTop;
WidgetScrollUpdateThumbs(w, widgetIndex);
widget_invalidate_by_number(w->classification, w->number, widgetIndex);
}

70
src/openrct2-ui/interface/Widget.cpp
View File

@@ -36,9 +36,9 @@ static void WidgetCheckboxDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widget
static void WidgetCloseboxDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetindex widgetIndex);
static void WidgetScrollDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetindex widgetIndex);
static void WidgetHScrollbarDraw(
rct_drawpixelinfo* dpi, rct_scroll* scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour);
rct_drawpixelinfo* dpi, const rct_scroll& scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour);
static void WidgetVScrollbarDraw(
rct_drawpixelinfo* dpi, rct_scroll* scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour);
rct_drawpixelinfo* dpi, const rct_scroll& scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour);
static void WidgetDrawImage(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetindex widgetIndex);
/**
@@ -652,7 +652,7 @@ static void WidgetScrollDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetin
// Get the widget
int32_t scrollIndex = window_get_scroll_data_index(w, widgetIndex);
const auto& widget = w->widgets[widgetIndex];
rct_scroll* scroll = &w->scrolls[scrollIndex];
const auto& scroll = w->scrolls[scrollIndex];
// Resolve the absolute ltrb
ScreenCoordsXY topLeft = w->windowPos + ScreenCoordsXY{ widget.left, widget.top };
@@ -671,22 +671,22 @@ static void WidgetScrollDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetin
bottomRight.y--;
// Horizontal scrollbar
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
WidgetHScrollbarDraw(
dpi, scroll, topLeft.x, bottomRight.y - SCROLLBAR_WIDTH,
((scroll->flags & VSCROLLBAR_VISIBLE) ? bottomRight.x - (SCROLLBAR_WIDTH + 1) : bottomRight.x), bottomRight.y,
((scroll.flags & VSCROLLBAR_VISIBLE) ? bottomRight.x - (SCROLLBAR_WIDTH + 1) : bottomRight.x), bottomRight.y,
colour);
// Vertical scrollbar
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
WidgetVScrollbarDraw(
dpi, scroll, bottomRight.x - SCROLLBAR_WIDTH, topLeft.y, bottomRight.x,
((scroll->flags & HSCROLLBAR_VISIBLE) ? bottomRight.y - (SCROLLBAR_WIDTH + 1) : bottomRight.y), colour);
((scroll.flags & HSCROLLBAR_VISIBLE) ? bottomRight.y - (SCROLLBAR_WIDTH + 1) : bottomRight.y), colour);
// Contents
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
bottomRight.y -= (SCROLLBAR_WIDTH + 1);
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
bottomRight.x -= (SCROLLBAR_WIDTH + 1);
bottomRight.y++;
@@ -702,8 +702,8 @@ static void WidgetScrollDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetin
int32_t cb = std::min<int32_t>(dpi->y + dpi->height, bottomRight.y);
// Set the respective dpi attributes
scroll_dpi.x = cl - topLeft.x + scroll->h_left;
scroll_dpi.y = ct - topLeft.y + scroll->v_top;
scroll_dpi.x = cl - topLeft.x + scroll.h_left;
scroll_dpi.y = ct - topLeft.y + scroll.v_top;
scroll_dpi.width = cr - cl;
scroll_dpi.height = cb - ct;
scroll_dpi.bits += cl - dpi->x;
@@ -716,7 +716,7 @@ static void WidgetScrollDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widgetin
}
static void WidgetHScrollbarDraw(
rct_drawpixelinfo* dpi, rct_scroll* scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour)
rct_drawpixelinfo* dpi, const rct_scroll& scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour)
{
colour &= 0x7F;
// Trough
@@ -729,7 +729,7 @@ static void WidgetHScrollbarDraw(
// Left button
{
uint8_t flags = (scroll->flags & HSCROLLBAR_LEFT_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
uint8_t flags = (scroll.flags & HSCROLLBAR_LEFT_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
gfx_fill_rect_inset(dpi, { { l, t }, { l + (SCROLLBAR_WIDTH - 1), b } }, colour, flags);
gfx_draw_string(dpi, { l + 1, t }, static_cast<const char*>(BlackLeftArrowString), {});
@@ -737,16 +737,16 @@ static void WidgetHScrollbarDraw(
// Thumb
{
int16_t left = std::max(l + SCROLLBAR_WIDTH, l + scroll->h_thumb_left - 1);
int16_t right = std::min(r - SCROLLBAR_WIDTH, l + scroll->h_thumb_right - 1);
uint8_t flags = (scroll->flags & HSCROLLBAR_THUMB_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
int16_t left = std::max(l + SCROLLBAR_WIDTH, l + scroll.h_thumb_left - 1);
int16_t right = std::min(r - SCROLLBAR_WIDTH, l + scroll.h_thumb_right - 1);
uint8_t flags = (scroll.flags & HSCROLLBAR_THUMB_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
gfx_fill_rect_inset(dpi, { { left, t }, { right, b } }, colour, flags);
}
// Right button
{
uint8_t flags = (scroll->flags & HSCROLLBAR_RIGHT_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
uint8_t flags = (scroll.flags & HSCROLLBAR_RIGHT_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0;
gfx_fill_rect_inset(dpi, { { r - (SCROLLBAR_WIDTH - 1), t }, { r, b } }, colour, flags);
gfx_draw_string(dpi, { r - 6, t }, static_cast<const char*>(BlackRightArrowString), {});
@@ -754,7 +754,7 @@ static void WidgetHScrollbarDraw(
}
static void WidgetVScrollbarDraw(
rct_drawpixelinfo* dpi, rct_scroll* scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour)
rct_drawpixelinfo* dpi, const rct_scroll& scroll, int32_t l, int32_t t, int32_t r, int32_t b, int32_t colour)
{
colour &= 0x7F;
// Trough
@@ -768,20 +768,20 @@ static void WidgetVScrollbarDraw(
// Up button
gfx_fill_rect_inset(
dpi, { { l, t }, { r, t + (SCROLLBAR_WIDTH - 1) } }, colour,
((scroll->flags & VSCROLLBAR_UP_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
((scroll.flags & VSCROLLBAR_UP_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
gfx_draw_string(dpi, { l + 1, t - 1 }, static_cast<const char*>(BlackUpArrowString), {});
// Thumb
gfx_fill_rect_inset(
dpi,
{ { l, std::max(t + SCROLLBAR_WIDTH, t + scroll->v_thumb_top - 1) },
{ r, std::min(b - SCROLLBAR_WIDTH, t + scroll->v_thumb_bottom - 1) } },
colour, ((scroll->flags & VSCROLLBAR_THUMB_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
{ { l, std::max(t + SCROLLBAR_WIDTH, t + scroll.v_thumb_top - 1) },
{ r, std::min(b - SCROLLBAR_WIDTH, t + scroll.v_thumb_bottom - 1) } },
colour, ((scroll.flags & VSCROLLBAR_THUMB_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
// Down button
gfx_fill_rect_inset(
dpi, { { l, b - (SCROLLBAR_WIDTH - 1) }, { r, b } }, colour,
((scroll->flags & VSCROLLBAR_DOWN_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
((scroll.flags & VSCROLLBAR_DOWN_PRESSED) ? INSET_RECT_FLAG_BORDER_INSET : 0));
gfx_draw_string(dpi, { l + 1, b - (SCROLLBAR_WIDTH - 1) }, static_cast<const char*>(BlackDownArrowString), {});
}
@@ -929,14 +929,14 @@ void WidgetScrollGetPart(
}
}
if ((w->scrolls[*scroll_id].flags & HSCROLLBAR_VISIBLE)
&& screenCoords.y >= (w->windowPos.y + widget->bottom - (SCROLLBAR_WIDTH + 1)))
const auto& scroll = w->scrolls[*scroll_id];
if ((scroll.flags & HSCROLLBAR_VISIBLE) && screenCoords.y >= (w->windowPos.y + widget->bottom - (SCROLLBAR_WIDTH + 1)))
{
// horizontal scrollbar
int32_t rightOffset = 0;
int32_t iteratorLeft = widget->left + w->windowPos.x + SCROLLBAR_WIDTH;
int32_t iteratorRight = widget->right + w->windowPos.x - SCROLLBAR_WIDTH;
if (!(w->scrolls[*scroll_id].flags & VSCROLLBAR_VISIBLE))
if (!(scroll.flags & VSCROLLBAR_VISIBLE))
{
rightOffset = SCROLLBAR_WIDTH + 1;
}
@@ -953,11 +953,11 @@ void WidgetScrollGetPart(
{
*output_scroll_area = SCROLL_PART_HSCROLLBAR_RIGHT;
}
else if (screenCoords.x < (widget->left + w->windowPos.x + w->scrolls[*scroll_id].h_thumb_left))
else if (screenCoords.x < (widget->left + w->windowPos.x + scroll.h_thumb_left))
{
*output_scroll_area = SCROLL_PART_HSCROLLBAR_LEFT_TROUGH;
}
else if (screenCoords.x > (widget->left + w->windowPos.x + w->scrolls[*scroll_id].h_thumb_right))
else if (screenCoords.x > (widget->left + w->windowPos.x + scroll.h_thumb_right))
{
*output_scroll_area = SCROLL_PART_HSCROLLBAR_RIGHT_TROUGH;
}
@@ -966,15 +966,13 @@ void WidgetScrollGetPart(
*output_scroll_area = SCROLL_PART_HSCROLLBAR_THUMB;
}
}
else if (
(w->scrolls[*scroll_id].flags & VSCROLLBAR_VISIBLE)
&& (screenCoords.x >= w->windowPos.x + widget->right - (SCROLLBAR_WIDTH + 1)))
else if ((scroll.flags & VSCROLLBAR_VISIBLE) && (screenCoords.x >= w->windowPos.x + widget->right - (SCROLLBAR_WIDTH + 1)))
{
// vertical scrollbar
int32_t bottomOffset = 0;
int32_t iteratorTop = widget->top + w->windowPos.y + SCROLLBAR_WIDTH;
int32_t iteratorBottom = widget->bottom + w->windowPos.y;
if (w->scrolls[*scroll_id].flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
{
bottomOffset = (SCROLLBAR_WIDTH + 1);
}
@@ -991,11 +989,11 @@ void WidgetScrollGetPart(
{
*output_scroll_area = SCROLL_PART_VSCROLLBAR_BOTTOM;
}
else if (screenCoords.y < (widget->top + w->windowPos.y + w->scrolls[*scroll_id].v_thumb_top))
else if (screenCoords.y < (widget->top + w->windowPos.y + scroll.v_thumb_top))
{
*output_scroll_area = SCROLL_PART_VSCROLLBAR_TOP_TROUGH;
}
else if (screenCoords.y > (widget->top + w->windowPos.y + w->scrolls[*scroll_id].v_thumb_bottom))
else if (screenCoords.y > (widget->top + w->windowPos.y + scroll.v_thumb_bottom))
{
*output_scroll_area = SCROLL_PART_VSCROLLBAR_BOTTOM_TROUGH;
}
@@ -1017,8 +1015,8 @@ void WidgetScrollGetPart(
}
else
{
retScreenCoords.x += w->scrolls[*scroll_id].h_left - 1;
retScreenCoords.y += w->scrolls[*scroll_id].v_top - 1;
retScreenCoords.x += scroll.h_left - 1;
retScreenCoords.y += scroll.v_top - 1;
}
}
}

41
src/openrct2-ui/interface/Window.cpp
View File

@@ -356,25 +356,25 @@ static rct_widget* WindowGetScrollWidget(rct_window* w, int32_t scrollIndex)
*/
static void WindowScrollWheelInput(rct_window* w, int32_t scrollIndex, int32_t wheel)
{
rct_scroll* scroll = &w->scrolls[scrollIndex];
auto& scroll = w->scrolls[scrollIndex];
rct_widget* widget = WindowGetScrollWidget(w, scrollIndex);
rct_widgetindex widgetIndex = WindowGetWidgetIndex(w, widget);
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
{
int32_t size = widget->height() - 1;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
size -= 11;
size = std::max(0, scroll->v_bottom - size);
scroll->v_top = std::min(std::max(0, scroll->v_top + wheel), size);
size = std::max(0, scroll.v_bottom - size);
scroll.v_top = std::min(std::max(0, scroll.v_top + wheel), size);
}
else
{
int32_t size = widget->width() - 1;
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
size -= 11;
size = std::max(0, scroll->h_right - size);
scroll->h_left = std::min(std::max(0, scroll->h_left + wheel), size);
size = std::max(0, scroll.h_right - size);
scroll.h_left = std::min(std::max(0, scroll.h_left + wheel), size);
}
WidgetScrollUpdateThumbs(w, widgetIndex);
@@ -394,8 +394,8 @@ static int32_t WindowWheelInput(rct_window* w, int32_t wheel)
continue;
// Originally always checked first scroll view, bug maybe?
rct_scroll* scroll = &w->scrolls[i];
if (scroll->flags & (HSCROLLBAR_VISIBLE | VSCROLLBAR_VISIBLE))
const auto& scroll = w->scrolls[i];
if (scroll.flags & (HSCROLLBAR_VISIBLE | VSCROLLBAR_VISIBLE))
{
WindowScrollWheelInput(w, i, wheel);
return 1;
@@ -542,8 +542,8 @@ void WindowAllWheelInput()
if (widget.type == WindowWidgetType::Scroll)
{
int32_t scrollIndex = WindowGetScrollIndex(w, widgetIndex);
rct_scroll* scroll = &w->scrolls[scrollIndex];
if (scroll->flags & (HSCROLLBAR_VISIBLE | VSCROLLBAR_VISIBLE))
const auto& scroll = w->scrolls[scrollIndex];
if (scroll.flags & (HSCROLLBAR_VISIBLE | VSCROLLBAR_VISIBLE))
{
WindowScrollWheelInput(w, WindowGetScrollIndex(w, widgetIndex), pixel_scroll);
return;
@@ -577,7 +577,6 @@ void ApplyScreenSaverLockSetting()
void WindowInitScrollWidgets(rct_window* w)
{
rct_widget* widget;
rct_scroll* scroll;
int32_t widget_index, scroll_index;
int32_t width, height;
@@ -591,20 +590,20 @@ void WindowInitScrollWidgets(rct_window* w)
continue;
}
scroll = &w->scrolls[scroll_index];
scroll->flags = 0;
auto& scroll = w->scrolls[scroll_index];
scroll.flags = 0;
width = 0;
height = 0;
window_get_scroll_size(w, scroll_index, &width, &height);
scroll->h_left = 0;
scroll->h_right = width + 1;
scroll->v_top = 0;
scroll->v_bottom = height + 1;
scroll.h_left = 0;
scroll.h_right = width + 1;
scroll.v_top = 0;
scroll.v_bottom = height + 1;
if (widget->content & SCROLL_HORIZONTAL)
scroll->flags |= HSCROLLBAR_VISIBLE;
scroll.flags |= HSCROLLBAR_VISIBLE;
if (widget->content & SCROLL_VERTICAL)
scroll->flags |= VSCROLLBAR_VISIBLE;
scroll.flags |= VSCROLLBAR_VISIBLE;
WidgetScrollUpdateThumbs(w, widget_index);

31
src/openrct2-ui/windows/Options.cpp
View File

@@ -1474,10 +1474,10 @@ static void window_options_audio_dropdown(rct_window* w, rct_widgetindex widgetI
}
}
static uint8_t get_scroll_percentage(rct_widget* widget, rct_scroll* scroll)
static uint8_t get_scroll_percentage(const rct_widget& widget, const rct_scroll& scroll)
{
uint8_t width = widget->width() - 1;
return static_cast<float>(scroll->h_left) / (scroll->h_right - width) * 100;
uint8_t width = widget.width() - 1;
return static_cast<float>(scroll.h_left) / (scroll.h_right - width) * 100;
}
static void window_options_audio_update(rct_window* w)
@@ -1486,10 +1486,9 @@ static void window_options_audio_update(rct_window* w)
if (w->page == WINDOW_OPTIONS_PAGE_AUDIO)
{
rct_widget* widget;
widget = &window_options_audio_widgets[WIDX_MASTER_VOLUME];
uint8_t master_volume = get_scroll_percentage(widget, &w->scrolls[0]);
const auto& masterVolumeWidget = window_options_audio_widgets[WIDX_MASTER_VOLUME];
const auto& masterVolumeScroll = w->scrolls[0];
uint8_t master_volume = get_scroll_percentage(masterVolumeWidget, masterVolumeScroll);
if (master_volume != gConfigSound.master_volume)
{
gConfigSound.master_volume = master_volume;
@@ -1497,8 +1496,9 @@ static void window_options_audio_update(rct_window* w)
widget_invalidate(w, WIDX_MASTER_VOLUME);
}
widget = &window_options_audio_widgets[WIDX_SOUND_VOLUME];
uint8_t sound_volume = get_scroll_percentage(widget, &w->scrolls[1]);
const auto& soundVolumeWidget = window_options_audio_widgets[WIDX_MASTER_VOLUME];
const auto& soundVolumeScroll = w->scrolls[1];
uint8_t sound_volume = get_scroll_percentage(soundVolumeWidget, soundVolumeScroll);
if (sound_volume != gConfigSound.sound_volume)
{
gConfigSound.sound_volume = sound_volume;
@@ -1506,8 +1506,9 @@ static void window_options_audio_update(rct_window* w)
widget_invalidate(w, WIDX_SOUND_VOLUME);
}
widget = &window_options_audio_widgets[WIDX_MUSIC_VOLUME];
uint8_t ride_music_volume = get_scroll_percentage(widget, &w->scrolls[2]);
const auto& musicVolumeWidget = window_options_audio_widgets[WIDX_MASTER_VOLUME];
const auto& musicVolumeScroll = w->scrolls[2];
uint8_t ride_music_volume = get_scroll_percentage(musicVolumeWidget, musicVolumeScroll);
if (ride_music_volume != gConfigSound.ride_music_volume)
{
gConfigSound.ride_music_volume = ride_music_volume;
@@ -1524,11 +1525,11 @@ static void window_options_audio_scrollgetsize(rct_window* w, int32_t scrollInde
static void initialize_scroll_position(rct_window* w, rct_widgetindex widget_index, int32_t scroll_id, uint8_t volume)
{
rct_widget* widget = &window_options_audio_widgets[widget_index];
rct_scroll* scroll = &w->scrolls[scroll_id];
const auto& widget = window_options_audio_widgets[widget_index];
auto& scroll = w->scrolls[scroll_id];
int widget_size = scroll->h_right - (widget->width() - 1);
scroll->h_left = ceil(volume / 100.0f * widget_size);
int32_t widget_size = scroll.h_right - (widget.width() - 1);
scroll.h_left = ceil(volume / 100.0f * widget_size);
WidgetScrollUpdateThumbs(w, widget_index);
}

82
src/openrct2/interface/Window.cpp
View File

@@ -568,7 +568,6 @@ void window_update_scroll_widgets(rct_window* w)
{
int32_t scrollIndex, width, height, scrollPositionChanged;
rct_widgetindex widgetIndex;
rct_scroll* scroll;
rct_widget* widget;
widgetIndex = 0;
@@ -579,32 +578,32 @@ void window_update_scroll_widgets(rct_window* w)
if (widget->type != WindowWidgetType::Scroll)
continue;
scroll = &w->scrolls[scrollIndex];
auto& scroll = w->scrolls[scrollIndex];
width = 0;
height = 0;
window_get_scroll_size(w, scrollIndex, &width, &height);
if (height == 0)
{
scroll->v_top = 0;
scroll.v_top = 0;
}
else if (width == 0)
{
scroll->h_left = 0;
scroll.h_left = 0;
}
width++;
height++;
scrollPositionChanged = 0;
if ((widget->content & SCROLL_HORIZONTAL) && width != scroll->h_right)
if ((widget->content & SCROLL_HORIZONTAL) && width != scroll.h_right)
{
scrollPositionChanged = 1;
scroll->h_right = width;
scroll.h_right = width;
}
if ((widget->content & SCROLL_VERTICAL) && height != scroll->v_bottom)
if ((widget->content & SCROLL_VERTICAL) && height != scroll.v_bottom)
{
scrollPositionChanged = 1;
scroll->v_bottom = height;
scroll.v_bottom = height;
}
if (scrollPositionChanged)
@@ -1292,8 +1291,9 @@ void window_resize(rct_window* w, int32_t dw, int32_t dh)
// Update scroll widgets
for (int32_t i = 0; i < 3; i++)
{
w->scrolls[i].h_right = WINDOW_SCROLL_UNDEFINED;
w->scrolls[i].v_bottom = WINDOW_SCROLL_UNDEFINED;
auto& scroll = w->scrolls[i];
scroll.h_right = WINDOW_SCROLL_UNDEFINED;
scroll.v_bottom = WINDOW_SCROLL_UNDEFINED;
}
window_update_scroll_widgets(w);
@@ -2183,63 +2183,63 @@ rct_windowclass window_get_classification(rct_window* window)
void WidgetScrollUpdateThumbs(rct_window* w, rct_widgetindex widget_index)
{
const auto& widget = w->widgets[widget_index];
rct_scroll* scroll = &w->scrolls[window_get_scroll_data_index(w, widget_index)];
auto& scroll = w->scrolls[window_get_scroll_data_index(w, widget_index)];
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
{
int32_t view_size = widget.width() - 21;
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
view_size -= 11;
int32_t x = scroll->h_left * view_size;
if (scroll->h_right != 0)
x /= scroll->h_right;
scroll->h_thumb_left = x + 11;
int32_t x = scroll.h_left * view_size;
if (scroll.h_right != 0)
x /= scroll.h_right;
scroll.h_thumb_left = x + 11;
x = widget.width() - 2;
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
x -= 11;
x += scroll->h_left;
if (scroll->h_right != 0)
x = (x * view_size) / scroll->h_right;
x += scroll.h_left;
if (scroll.h_right != 0)
x = (x * view_size) / scroll.h_right;
x += 11;
view_size += 10;
scroll->h_thumb_right = std::min(x, view_size);
scroll.h_thumb_right = std::min(x, view_size);
if (scroll->h_thumb_right - scroll->h_thumb_left < 20)
if (scroll.h_thumb_right - scroll.h_thumb_left < 20)
{
double barPosition = (scroll->h_thumb_right * 1.0) / view_size;
double barPosition = (scroll.h_thumb_right * 1.0) / view_size;
scroll->h_thumb_left = static_cast<uint16_t>(std::lround(scroll->h_thumb_left - (20 * barPosition)));
scroll->h_thumb_right = static_cast<uint16_t>(std::lround(scroll->h_thumb_right + (20 * (1 - barPosition))));
scroll.h_thumb_left = static_cast<uint16_t>(std::lround(scroll.h_thumb_left - (20 * barPosition)));
scroll.h_thumb_right = static_cast<uint16_t>(std::lround(scroll.h_thumb_right + (20 * (1 - barPosition))));
}
}
if (scroll->flags & VSCROLLBAR_VISIBLE)
if (scroll.flags & VSCROLLBAR_VISIBLE)
{
int32_t view_size = widget.height() - 21;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
view_size -= 11;
int32_t y = scroll->v_top * view_size;
if (scroll->v_bottom != 0)
y /= scroll->v_bottom;
scroll->v_thumb_top = y + 11;
int32_t y = scroll.v_top * view_size;
if (scroll.v_bottom != 0)
y /= scroll.v_bottom;
scroll.v_thumb_top = y + 11;
y = widget.height() - 2;
if (scroll->flags & HSCROLLBAR_VISIBLE)
if (scroll.flags & HSCROLLBAR_VISIBLE)
y -= 11;
y += scroll->v_top;
if (scroll->v_bottom != 0)
y = (y * view_size) / scroll->v_bottom;
y += scroll.v_top;
if (scroll.v_bottom != 0)
y = (y * view_size) / scroll.v_bottom;
y += 11;
view_size += 10;
scroll->v_thumb_bottom = std::min(y, view_size);
scroll.v_thumb_bottom = std::min(y, view_size);
if (scroll->v_thumb_bottom - scroll->v_thumb_top < 20)
if (scroll.v_thumb_bottom - scroll.v_thumb_top < 20)
{
double barPosition = (scroll->v_thumb_bottom * 1.0) / view_size;
double barPosition = (scroll.v_thumb_bottom * 1.0) / view_size;
scroll->v_thumb_top = static_cast<uint16_t>(std::lround(scroll->v_thumb_top - (20 * barPosition)));
scroll->v_thumb_bottom = static_cast<uint16_t>(std::lround(scroll->v_thumb_bottom + (20 * (1 - barPosition))));
scroll.v_thumb_top = static_cast<uint16_t>(std::lround(scroll.v_thumb_top - (20 * barPosition)));
scroll.v_thumb_bottom = static_cast<uint16_t>(std::lround(scroll.v_thumb_bottom + (20 * (1 - barPosition))));
}
}
}