mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Replace gfx_draw_string_left() with DrawTextBasic()

This commit is contained in:
Gymnasiast 2021-02-27 16:49:13 +01:00
parent d5f79b7972
commit e2ebc9d43b
No known key found for this signature in database
GPG Key ID: DBFFF47AB2CA3EDD
41 changed files with 591 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -483,7 +483,7 @@ static void WidgetGroupboxDraw(rct_drawpixelinfo* dpi, rct_window* w, rct_widget
format_string(buffer, sizeof(buffer), stringId, formatArgs);
auto ft = Formatter();
ft.Add<utf8*>(buffer);
gfx_draw_string_left(dpi, STR_STRING, ft.Data(), colour, { l, t });
DrawTextBasic(dpi, { l, t }, STR_STRING, ft, { colour });
textRight = l + gfx_get_string_width(buffer) + 1;
}

40
src/openrct2-ui/windows/Cheats.cpp
View File

@ -614,7 +614,7 @@ public:
if (page == WINDOW_CHEATS_PAGE_MONEY)
{
uint8_t colour = colours[1];
auto colour = colours[1];
auto ft = Formatter();
ft.Add<money32>(_moneySpinnerValue);
if (IsWidgetDisabled(WIDX_MONEY_SPINNER))
@ -622,10 +622,10 @@ public:
colour |= COLOUR_FLAG_INSET;
}
int32_t actual_month = _monthSpinnerValue - 1;
gfx_draw_string_left(&dpi, STR_BOTTOM_TOOLBAR_CASH, ft.Data(), colour, windowPos + ScreenCoordsXY{ X_LCOL, 93 });
gfx_draw_string_left(&dpi, STR_YEAR, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 198 });
gfx_draw_string_left(&dpi, STR_MONTH, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 219 });
gfx_draw_string_left(&dpi, STR_DAY, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 240 });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 93 }, STR_BOTTOM_TOOLBAR_CASH, ft, { colour });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 198 }, STR_YEAR);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 219 }, STR_MONTH);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 240 }, STR_DAY);
ft = Formatter();
ft.Add<int32_t>(_yearSpinnerValue);
DrawTextBasic(
@ -643,8 +643,7 @@ public:
{
{
auto& widget = widgets[WIDX_WEATHER];
gfx_draw_string_left(
&dpi, STR_CHANGE_WEATHER, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL - 3, widget.top + 1 });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL - 3, widget.top + 1 }, STR_CHANGE_WEATHER);
}
{
@ -659,28 +658,19 @@ public:
{
auto& widget = widgets[WIDX_STAFF_SPEED];
gfx_draw_string_left(
&dpi, STR_CHEAT_STAFF_SPEED, nullptr, COLOUR_BLACK,
windowPos + ScreenCoordsXY{ X_LCOL - 3, widget.top + 1 });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL - 3, widget.top + 1 }, STR_CHEAT_STAFF_SPEED);
}
}
else if (page == WINDOW_CHEATS_PAGE_GUESTS)
{
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_HAPPINESS, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 72 });
gfx_draw_string_left(&dpi, STR_CHEAT_GUEST_ENERGY, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 93 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_HUNGER, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 114 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_THIRST, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 135 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_NAUSEA, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 156 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_NAUSEA_TOLERANCE, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 177 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_TOILET, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 198 });
gfx_draw_string_left(
&dpi, STR_CHEAT_GUEST_PREFERRED_INTENSITY, nullptr, COLOUR_BLACK, windowPos + ScreenCoordsXY{ X_LCOL, 219 });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 72 }, STR_CHEAT_GUEST_HAPPINESS);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 93 }, STR_CHEAT_GUEST_ENERGY);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 114 }, STR_CHEAT_GUEST_HUNGER);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 135 }, STR_CHEAT_GUEST_THIRST);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 156 }, STR_CHEAT_GUEST_NAUSEA);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 177 }, STR_CHEAT_GUEST_NAUSEA_TOLERANCE);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 198 }, STR_CHEAT_GUEST_TOILET);
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ X_LCOL, 219 }, STR_CHEAT_GUEST_PREFERRED_INTENSITY);
}
}

30
src/openrct2-ui/windows/CustomCurrency.cpp
View File

@ -218,17 +218,16 @@ static void custom_currency_window_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto screenCoords = w->windowPos + ScreenCoordsXY{ 10, 30 };
gfx_draw_string_left(dpi, STR_RATE, nullptr, w->colours[1], screenCoords);
DrawTextBasic(dpi, screenCoords, STR_RATE, {}, { w->colours[1] });
int32_t baseExchange = CurrencyDescriptors[EnumValue(CurrencyType::Pounds)].rate;
ft = Formatter();
ft.Add<int32_t>(baseExchange);
gfx_draw_string_left(
dpi, STR_CUSTOM_CURRENCY_EQUIVALENCY, ft.Data(), w->colours[1], screenCoords + ScreenCoordsXY{ 200, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 200, 0 }, STR_CUSTOM_CURRENCY_EQUIVALENCY, ft, { w->colours[1] });
screenCoords.y += 20;
gfx_draw_string_left(dpi, STR_CURRENCY_SYMBOL_TEXT, nullptr, w->colours[1], screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_SYMBOL_TEXT, {}, { w->colours[1] });
screenCoords = w->windowPos
+ ScreenCoordsXY{ window_custom_currency_widgets[WIDX_SYMBOL_TEXT].left + 1,
@ -236,20 +235,11 @@ static void custom_currency_window_paint(rct_window* w, rct_drawpixelinfo* dpi)
gfx_draw_string(dpi, CurrencyDescriptors[EnumValue(CurrencyType::Custom)].symbol_unicode, w->colours[1], screenCoords);
if (CurrencyDescriptors[EnumValue(CurrencyType::Custom)].affix_unicode == CurrencyAffix::Prefix)
{
gfx_draw_string_left(
dpi, STR_PREFIX, w, w->colours[1],
w->windowPos
+ ScreenCoordsXY{ window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].left + 1,
window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].top });
}
else
{
gfx_draw_string_left(
dpi, STR_SUFFIX, w, w->colours[1],
w->windowPos
+ ScreenCoordsXY{ window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].left + 1,
window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].top });
}
auto drawPos = w->windowPos
+ ScreenCoordsXY{ window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].left + 1,
window_custom_currency_widgets[WIDX_AFFIX_DROPDOWN].top };
rct_string_id stringId = (CurrencyDescriptors[EnumValue(CurrencyType::Custom)].affix_unicode == CurrencyAffix::Prefix)
? STR_PREFIX
: STR_SUFFIX;
DrawTextBasic(dpi, drawPos, stringId, w, { w->colours[1] });
}

6
src/openrct2-ui/windows/EditorInventionsList.cpp
View File

@ -509,12 +509,12 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
// Pre-researched items label
screenPos = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_PRE_RESEARCHED_SCROLL].left, w->widgets[WIDX_PRE_RESEARCHED_SCROLL].top - 11 };
gfx_draw_string_left(dpi, STR_INVENTION_PREINVENTED_ITEMS, nullptr, COLOUR_BLACK, screenPos - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenPos - ScreenCoordsXY{ 0, 1 }, STR_INVENTION_PREINVENTED_ITEMS);
// Research order label
screenPos = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_RESEARCH_ORDER_SCROLL].left, w->widgets[WIDX_RESEARCH_ORDER_SCROLL].top - 11 };
gfx_draw_string_left(dpi, STR_INVENTION_TO_BE_INVENTED_ITEMS, nullptr, COLOUR_BLACK, screenPos - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenPos - ScreenCoordsXY{ 0, 1 }, STR_INVENTION_TO_BE_INVENTED_ITEMS);
// Preview background
widget = &w->widgets[WIDX_PREVIEW];
@ -567,7 +567,7 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
// Item category
screenPos.x = w->windowPos.x + w->widgets[WIDX_RESEARCH_ORDER_SCROLL].right + 4;
stringId = researchItem->GetCategoryInventionString();
gfx_draw_string_left(dpi, STR_INVENTION_RESEARCH_GROUP, &stringId, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_INVENTION_RESEARCH_GROUP, &stringId);
}
/**

2
src/openrct2-ui/windows/EditorObjectSelection.cpp
View File

@ -1006,7 +1006,7 @@ static void window_editor_object_selection_paint(rct_window* w, rct_drawpixelinf
auto ft = Formatter();
ft.Add<uint16_t>(numSelected);
ft.Add<uint16_t>(totalSelectable);
gfx_draw_string_left(dpi, STR_OBJECT_SELECTION_SELECTION_SIZE, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_OBJECT_SELECTION_SELECTION_SIZE, ft);
}
// Draw sort button text

25
src/openrct2-ui/windows/EditorObjectiveOptions.cpp
View File

@ -797,12 +797,12 @@ static void window_editor_objective_options_main_paint(rct_window* w, rct_drawpi
// Objective label
auto screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_OBJECTIVE].top };
gfx_draw_string_left(dpi, STR_OBJECTIVE_WINDOW, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_OBJECTIVE_WINDOW);
// Objective value
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_OBJECTIVE].left + 1, w->widgets[WIDX_OBJECTIVE].top };
stringId = ObjectiveDropdownOptionNames[gScenarioObjective.Type];
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, &stringId, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, &stringId);
if (w->widgets[WIDX_OBJECTIVE_ARG_1].type != WindowWidgetType::Empty)
{
@ -831,7 +831,7 @@ static void window_editor_objective_options_main_paint(rct_window* w, rct_drawpi
stringId = STR_WINDOW_OBJECTIVE_EXCITEMENT_RATING;
break;
}
gfx_draw_string_left(dpi, stringId, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId);
// Objective argument 1 value
screenCoords = w->windowPos
@ -863,20 +863,20 @@ static void window_editor_objective_options_main_paint(rct_window* w, rct_drawpi
arg = gScenarioObjective.Currency;
break;
}
gfx_draw_string_left(dpi, stringId, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &arg, COLOUR_BLACK);
}
if (w->widgets[WIDX_OBJECTIVE_ARG_2].type != WindowWidgetType::Empty)
{
// Objective argument 2 label
screenCoords = w->windowPos + ScreenCoordsXY{ 28, w->widgets[WIDX_OBJECTIVE_ARG_2].top };
gfx_draw_string_left(dpi, STR_WINDOW_OBJECTIVE_DATE, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_OBJECTIVE_DATE);
// Objective argument 2 value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_OBJECTIVE_ARG_2].left + 1, w->widgets[WIDX_OBJECTIVE_ARG_2].top };
arg = (gScenarioObjective.Year * MONTH_COUNT) - 1;
gfx_draw_string_left(dpi, STR_WINDOW_OBJECTIVE_VALUE_DATE, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_OBJECTIVE_VALUE_DATE, &arg);
}
// Park name
@ -904,7 +904,7 @@ static void window_editor_objective_options_main_paint(rct_window* w, rct_drawpi
// Scenario details label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_DETAILS].top };
gfx_draw_string_left(dpi, STR_WINDOW_PARK_DETAILS, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_PARK_DETAILS);
// Scenario details value
screenCoords = w->windowPos + ScreenCoordsXY{ 16, w->widgets[WIDX_DETAILS].top + 10 };
@ -917,12 +917,12 @@ static void window_editor_objective_options_main_paint(rct_window* w, rct_drawpi
// Scenario category label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CATEGORY].top };
gfx_draw_string_left(dpi, STR_WINDOW_SCENARIO_GROUP, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_SCENARIO_GROUP);
// Scenario category value
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_CATEGORY].left + 1, w->widgets[WIDX_CATEGORY].top };
stringId = ScenarioCategoryStringIds[gS6Info.category];
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, &stringId, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, &stringId);
}
/**
@ -1062,9 +1062,8 @@ static void window_editor_objective_options_rides_paint(rct_window* w, rct_drawp
WindowDrawWidgets(w, dpi);
window_editor_objective_options_draw_tab_images(w, dpi);
gfx_draw_string_left(
dpi, STR_WINDOW_PRESERVATION_ORDER, nullptr, COLOUR_BLACK,
w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PAGE_BACKGROUND].top + 3 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PAGE_BACKGROUND].top + 3 }, STR_WINDOW_PRESERVATION_ORDER);
}
/**
@ -1109,7 +1108,7 @@ static void window_editor_objective_options_rides_scrollpaint(rct_window* w, rct
Formatter ft;
ride->FormatNameTo(ft);
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, { 15, y });
DrawTextBasic(dpi, { 15, y }, stringId, ft);
}
}
}

50
src/openrct2-ui/windows/EditorScenarioOptions.cpp
View File

@ -686,43 +686,43 @@ static void window_editor_scenario_options_financial_paint(rct_window* w, rct_dr
if (w->widgets[WIDX_INITIAL_CASH].type != WindowWidgetType::Empty)
{
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_INITIAL_CASH].top };
gfx_draw_string_left(dpi, STR_INIT_CASH_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INIT_CASH_LABEL);
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_INITIAL_CASH].left + 1, w->widgets[WIDX_INITIAL_CASH].top };
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &gInitialCash, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &gInitialCash);
}
if (w->widgets[WIDX_INITIAL_LOAN].type != WindowWidgetType::Empty)
{
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_INITIAL_LOAN].top };
gfx_draw_string_left(dpi, STR_INIT_LOAN_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INIT_LOAN_LABEL);
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_INITIAL_LOAN].left + 1, w->widgets[WIDX_INITIAL_LOAN].top };
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &gBankLoan, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &gBankLoan);
}
if (w->widgets[WIDX_MAXIMUM_LOAN].type != WindowWidgetType::Empty)
{
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_MAXIMUM_LOAN].top };
gfx_draw_string_left(dpi, STR_MAX_LOAN_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_MAX_LOAN_LABEL);
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_MAXIMUM_LOAN].left + 1, w->widgets[WIDX_MAXIMUM_LOAN].top };
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &gMaxBankLoan, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &gMaxBankLoan);
}
if (w->widgets[WIDX_INTEREST_RATE].type != WindowWidgetType::Empty)
{
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_INTEREST_RATE].top };
gfx_draw_string_left(dpi, STR_INTEREST_RATE_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INTEREST_RATE_LABEL);
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_INTEREST_RATE].left + 1, w->widgets[WIDX_INTEREST_RATE].top };
int16_t interestRate = std::clamp<int16_t>(static_cast<int16_t>(gBankLoanInterestRate), INT16_MIN, INT16_MAX);
gfx_draw_string_left(dpi, STR_PERCENT_FORMAT_LABEL, &interestRate, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PERCENT_FORMAT_LABEL, &interestRate);
}
}
@ -965,44 +965,44 @@ static void window_editor_scenario_options_guests_paint(rct_window* w, rct_drawp
{
// Cash per guest label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CASH_PER_GUEST].top };
gfx_draw_string_left(dpi, STR_CASH_PER_GUEST_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CASH_PER_GUEST_LABEL);
// Cash per guest value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_CASH_PER_GUEST].left + 1, w->widgets[WIDX_CASH_PER_GUEST].top };
arg = gGuestInitialCash;
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &arg);
}
// Guest initial happiness label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_GUEST_INITIAL_HAPPINESS].top };
gfx_draw_string_left(dpi, STR_GUEST_INIT_HAPPINESS, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_INIT_HAPPINESS);
// Guest initial happiness value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GUEST_INITIAL_HAPPINESS].left + 1, w->widgets[WIDX_GUEST_INITIAL_HAPPINESS].top };
arg = (gGuestInitialHappiness * 100) / 255;
gfx_draw_string_left(dpi, STR_PERCENT_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PERCENT_FORMAT_LABEL, &arg);
// Guest initial hunger label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_GUEST_INITIAL_HUNGER].top };
gfx_draw_string_left(dpi, STR_GUEST_INIT_HUNGER, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_INIT_HUNGER);
// Guest initial hunger value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GUEST_INITIAL_HUNGER].left + 1, w->widgets[WIDX_GUEST_INITIAL_HUNGER].top };
arg = ((255 - gGuestInitialHunger) * 100) / 255;
gfx_draw_string_left(dpi, STR_PERCENT_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PERCENT_FORMAT_LABEL, &arg);
// Guest initial thirst label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_GUEST_INITIAL_THIRST].top };
gfx_draw_string_left(dpi, STR_GUEST_INIT_THIRST, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_INIT_THIRST);
// Guest initial thirst value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GUEST_INITIAL_THIRST].left + 1, w->widgets[WIDX_GUEST_INITIAL_THIRST].top };
arg = ((255 - gGuestInitialThirst) * 100) / 255;
gfx_draw_string_left(dpi, STR_PERCENT_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PERCENT_FORMAT_LABEL, &arg);
}
#pragma endregion
@ -1327,26 +1327,26 @@ static void window_editor_scenario_options_park_paint(rct_window* w, rct_drawpix
{
// Cost to buy land label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_LAND_COST].top };
gfx_draw_string_left(dpi, STR_LAND_COST_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_LAND_COST_LABEL);
// Cost to buy land value
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_LAND_COST].left + 1, w->widgets[WIDX_LAND_COST].top };
arg = gLandPrice;
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &arg);
}
if (w->widgets[WIDX_CONSTRUCTION_RIGHTS_COST].type != WindowWidgetType::Empty)
{
// Cost to buy construction rights label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CONSTRUCTION_RIGHTS_COST].top };
gfx_draw_string_left(dpi, STR_RIGHTS_COST_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_RIGHTS_COST_LABEL);
// Cost to buy construction rights value
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_CONSTRUCTION_RIGHTS_COST].left + 1,
w->widgets[WIDX_CONSTRUCTION_RIGHTS_COST].top };
arg = gConstructionRightsPrice;
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &arg);
}
if (w->widgets[WIDX_PAY_FOR_PARK_OR_RIDES].type != WindowWidgetType::Empty)
@ -1363,7 +1363,7 @@ static void window_editor_scenario_options_park_paint(rct_window* w, rct_drawpix
else
stringId = STR_PAY_PARK_ENTER;
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, &stringId, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, &stringId);
}
if (w->widgets[WIDX_ENTRY_PRICE].type != WindowWidgetType::Empty)
@ -1371,22 +1371,22 @@ static void window_editor_scenario_options_park_paint(rct_window* w, rct_drawpix
// Entry price label
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_PAY_FOR_PARK_OR_RIDES].right + 8, w->widgets[WIDX_ENTRY_PRICE].top };
gfx_draw_string_left(dpi, STR_ENTRY_PRICE_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_ENTRY_PRICE_LABEL);
// Entry price value
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_ENTRY_PRICE].left + 1, w->widgets[WIDX_ENTRY_PRICE].top };
arg = gParkEntranceFee;
gfx_draw_string_left(dpi, STR_CURRENCY_FORMAT_LABEL, &arg, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CURRENCY_FORMAT_LABEL, &arg);
}
// Climate label
screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CLIMATE].top };
gfx_draw_string_left(dpi, STR_CLIMATE_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CLIMATE_LABEL);
// Climate value
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_CLIMATE].left + 1, w->widgets[WIDX_CLIMATE].top };
stringId = ClimateNames[static_cast<uint8_t>(gClimate)];
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, &stringId, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, &stringId);
}
#pragma endregion

48
src/openrct2-ui/windows/Finances.cpp
View File

@ -544,8 +544,7 @@ static void window_finances_summary_paint(rct_window* w, rct_drawpixelinfo* dpi)
dpi, { screenCoords - ScreenCoordsXY{ 0, 1 }, screenCoords + ScreenCoordsXY{ 121, (TABLE_CELL_HEIGHT - 2) } },
ColourMapA[w->colours[1]].lighter | 0x1000000);
gfx_draw_string_left(
dpi, window_finances_summary_row_labels[i], nullptr, COLOUR_BLACK, screenCoords - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenCoords - ScreenCoordsXY{ 0, 1 }, window_finances_summary_row_labels[i]);
screenCoords.y += TABLE_CELL_HEIGHT;
}
@ -555,15 +554,14 @@ static void window_finances_summary_paint(rct_window* w, rct_drawpixelinfo* dpi)
INSET_RECT_FLAG_BORDER_INSET);
// Loan and interest rate
gfx_draw_string_left(dpi, STR_FINANCES_SUMMARY_LOAN, nullptr, COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 8, 279 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 8, 279 }, STR_FINANCES_SUMMARY_LOAN);
auto ft = Formatter();
ft.Add<uint16_t>(gBankLoanInterestRate);
gfx_draw_string_left(
dpi, STR_FINANCES_SUMMARY_AT_X_PER_YEAR, ft.Data(), COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 167, 279 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 167, 279 }, STR_FINANCES_SUMMARY_AT_X_PER_YEAR, ft);
// Current cash
rct_string_id stringId = gCash >= 0 ? STR_CASH_LABEL : STR_CASH_NEGATIVE_LABEL;
gfx_draw_string_left(dpi, stringId, &gCash, COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 8, 294 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 8, 294 }, stringId, &gCash);
// Objective related financial information
if (gScenarioObjective.Type == OBJECTIVE_MONTHLY_FOOD_INCOME)
@ -571,16 +569,14 @@ static void window_finances_summary_paint(rct_window* w, rct_drawpixelinfo* dpi)
money32 lastMonthProfit = finance_get_last_month_shop_profit();
ft = Formatter();
ft.Add<money32>(lastMonthProfit);
gfx_draw_string_left(
dpi, STR_LAST_MONTH_PROFIT_FROM_FOOD_DRINK_MERCHANDISE_SALES_LABEL, ft.Data(), COLOUR_BLACK,
w->windowPos + ScreenCoordsXY{ 280, 279 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 280, 279 }, STR_LAST_MONTH_PROFIT_FROM_FOOD_DRINK_MERCHANDISE_SALES_LABEL, ft);
}
else
{
// Park value and company value
gfx_draw_string_left(dpi, STR_PARK_VALUE_LABEL, &gParkValue, COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 280, 279 });
gfx_draw_string_left(
dpi, STR_COMPANY_VALUE_LABEL, &gCompanyValue, COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 280, 294 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 280, 279 }, STR_PARK_VALUE_LABEL, &gParkValue);
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 280, 294 }, STR_COMPANY_VALUE_LABEL, &gCompanyValue);
}
}
@ -723,11 +719,11 @@ static void window_finances_financial_graph_paint(rct_window* w, rct_drawpixelin
// Cash (less loan)
money32 cashLessLoan = gCash - gBankLoan;
gfx_draw_string_left(
dpi,
DrawTextBasic(
dpi, { graphLeft, graphTop - 11 },
cashLessLoan >= 0 ? STR_FINANCES_FINANCIAL_GRAPH_CASH_LESS_LOAN_POSITIVE
: STR_FINANCES_FINANCIAL_GRAPH_CASH_LESS_LOAN_NEGATIVE,
&cashLessLoan, COLOUR_BLACK, { graphLeft, graphTop - 11 });
&cashLessLoan);
// Graph
gfx_fill_rect_inset(dpi, graphLeft, graphTop, graphRight, graphBottom, w->colours[1], INSET_RECT_F_30);
@ -832,7 +828,7 @@ static void window_finances_park_value_graph_paint(rct_window* w, rct_drawpixeli
// Park value
money32 parkValue = gParkValue;
gfx_draw_string_left(dpi, STR_FINANCES_PARK_VALUE, &parkValue, COLOUR_BLACK, { graphLeft, graphTop - 11 });
DrawTextBasic(dpi, { graphLeft, graphTop - 11 }, STR_FINANCES_PARK_VALUE, &parkValue);
// Graph
gfx_fill_rect_inset(dpi, graphLeft, graphTop, graphRight, graphBottom, w->colours[1], INSET_RECT_F_30);
@ -936,9 +932,9 @@ static void window_finances_profit_graph_paint(rct_window* w, rct_drawpixelinfo*
// Weekly profit
money32 weeklyPofit = gCurrentProfit;
gfx_draw_string_left(
dpi, weeklyPofit >= 0 ? STR_FINANCES_WEEKLY_PROFIT_POSITIVE : STR_FINANCES_WEEKLY_PROFIT_LOSS, &weeklyPofit,
COLOUR_BLACK, { graphLeft, graphTop - 11 });
DrawTextBasic(
dpi, { graphLeft, graphTop - 11 },
weeklyPofit >= 0 ? STR_FINANCES_WEEKLY_PROFIT_POSITIVE : STR_FINANCES_WEEKLY_PROFIT_LOSS, &weeklyPofit);
// Graph
gfx_fill_rect_inset(dpi, graphLeft, graphTop, graphRight, graphBottom, w->colours[1], INSET_RECT_F_30);
@ -1107,16 +1103,16 @@ static void window_finances_marketing_paint(rct_window* w, rct_drawpixelinfo* dp
// Duration
uint16_t weeksRemaining = campaign->WeeksLeft;
gfx_draw_string_left(
dpi, weeksRemaining == 1 ? STR_1_WEEK_REMAINING : STR_X_WEEKS_REMAINING, &weeksRemaining, COLOUR_BLACK,
screenCoords + ScreenCoordsXY{ 304, 0 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 304, 0 }, weeksRemaining == 1 ? STR_1_WEEK_REMAINING : STR_X_WEEKS_REMAINING,
&weeksRemaining);
screenCoords.y += LIST_ROW_HEIGHT;
}
if (noCampaignsActive)
{
gfx_draw_string_left(dpi, STR_MARKETING_CAMPAIGNS_NONE, nullptr, COLOUR_BLACK, screenCoords + ScreenCoordsXY{ 4, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 4, 0 }, STR_MARKETING_CAMPAIGNS_NONE);
screenCoords.y += LIST_ROW_HEIGHT;
}
screenCoords.y += 34;
@ -1129,10 +1125,8 @@ static void window_finances_marketing_paint(rct_window* w, rct_drawpixelinfo* dp
{
// Draw button text
money32 pricePerWeek = AdvertisingCampaignPricePerWeek[i];
gfx_draw_string_left(
dpi, MarketingCampaignNames[i][0], nullptr, COLOUR_BLACK, screenCoords + ScreenCoordsXY{ 4, 0 });
gfx_draw_string_left(
dpi, STR_MARKETING_PER_WEEK, &pricePerWeek, COLOUR_BLACK, screenCoords + ScreenCoordsXY{ WH_SUMMARY, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 4, 0 }, MarketingCampaignNames[i][0]);
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ WH_SUMMARY, 0 }, STR_MARKETING_PER_WEEK, &pricePerWeek);
screenCoords.y += BUTTON_FACE_HEIGHT + 2;
}

2
src/openrct2-ui/windows/GameBottomToolbar.cpp
View File

@ -523,7 +523,7 @@ static void window_game_bottom_toolbar_draw_right_panel(rct_drawpixelinfo* dpi,
}
ft = Formatter();
ft.Add<int16_t>(temperature);
gfx_draw_string_left(dpi, format, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ 0, 6 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 0, 6 }, format, ft);
screenCoords.x += 30;
// Current weather

64
src/openrct2-ui/windows/Guest.cpp
View File

@ -1318,7 +1318,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
window_guest_rides_widgets[WIDX_PAGE_BACKGROUND].top + 4 };
// Happiness
gfx_draw_string_left(dpi, STR_GUEST_STAT_HAPPINESS_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_HAPPINESS_LABEL);
int32_t happiness = NormalizeGuestStatValue(peep->Happiness, PEEP_MAX_HAPPINESS, 10);
int32_t barColour = COLOUR_BRIGHT_GREEN;
@ -1327,7 +1327,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Energy
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_GUEST_STAT_ENERGY_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_ENERGY_LABEL);
int32_t energy = NormalizeGuestStatValue(peep->Energy - PEEP_MIN_ENERGY, PEEP_MAX_ENERGY - PEEP_MIN_ENERGY, 10);
barColour = COLOUR_BRIGHT_GREEN;
@ -1336,7 +1336,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Hunger
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_GUEST_STAT_HUNGER_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_HUNGER_LABEL);
int32_t hunger = NormalizeGuestStatValue(peep->Hunger - 32, 158, 0);
hunger = 255 - hunger; // the bar should be longer when peep->Hunger is low
@ -1346,7 +1346,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Thirst
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_GUEST_STAT_THIRST_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_THIRST_LABEL);
int32_t thirst = NormalizeGuestStatValue(peep->Thirst - 32, 158, 0);
thirst = 255 - thirst; // the bar should be longer when peep->Thirst is low
@ -1356,7 +1356,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Nausea
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_GUEST_STAT_NAUSEA_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_NAUSEA_LABEL);
int32_t nausea = NormalizeGuestStatValue(peep->Nausea - 32, 223, 0);
barColour = COLOUR_BRIGHT_RED;
@ -1365,7 +1365,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Toilet
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_GUEST_STAT_TOILET_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_TOILET_LABEL);
int32_t toilet = NormalizeGuestStatValue(peep->Toilet - 64, 178, 0);
barColour = COLOUR_BRIGHT_RED;
@ -1380,7 +1380,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t timeInPark = (gScenarioTicks - guestEntryTime) >> 11;
auto ft = Formatter();
ft.Add<uint16_t>(timeInPark & 0xFFFF);
gfx_draw_string_left(dpi, STR_GUEST_STAT_TIME_IN_PARK, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_TIME_IN_PARK, ft);
}
screenCoords.y += LIST_ROW_HEIGHT + 9;
@ -1389,7 +1389,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
INSET_RECT_FLAG_BORDER_INSET);
// Preferred Ride
gfx_draw_string_left(dpi, STR_GUEST_STAT_PREFERRED_RIDE, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_PREFERRED_RIDE);
screenCoords.y += LIST_ROW_HEIGHT;
// Intensity
@ -1410,7 +1410,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<uint16_t>(maxIntensity);
}
gfx_draw_string_left(dpi, string_id, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ 4, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 4, 0 }, string_id, ft);
}
// Nausea tolerance
@ -1425,7 +1425,7 @@ void window_guest_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto nausea_tolerance = EnumValue(peep->NauseaTolerance) & 0x3;
auto ft = Formatter();
ft.Add<rct_string_id>(nauseaTolerances[nausea_tolerance]);
gfx_draw_string_left(dpi, STR_GUEST_STAT_NAUSEA_TOLERANCE, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_NAUSEA_TOLERANCE, ft);
}
}
@ -1570,7 +1570,7 @@ void window_guest_rides_paint(rct_window* w, rct_drawpixelinfo* dpi)
+ ScreenCoordsXY{ window_guest_rides_widgets[WIDX_PAGE_BACKGROUND].left + 2,
window_guest_rides_widgets[WIDX_PAGE_BACKGROUND].top + 2 };
gfx_draw_string_left(dpi, STR_GUEST_LABEL_RIDES_BEEN_ON, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_LABEL_RIDES_BEEN_ON);
screenCoords.y = w->windowPos.y + window_guest_rides_widgets[WIDX_PAGE_BACKGROUND].bottom - 12;
@ -1612,7 +1612,7 @@ void window_guest_rides_scroll_paint(rct_window* w, rct_drawpixelinfo* dpi, int3
{
auto ft = Formatter();
ride->FormatNameTo(ft);
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, { 0, y - 1 });
DrawTextBasic(dpi, { 0, y - 1 }, stringId, ft);
}
}
}
@ -1659,7 +1659,7 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<money32>(peep->CashInPocket);
gfx_draw_string_left(dpi, STR_GUEST_STAT_CASH_IN_POCKET, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_CASH_IN_POCKET, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -1667,7 +1667,7 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<money32>(peep->CashSpent);
gfx_draw_string_left(dpi, STR_GUEST_STAT_CASH_SPENT, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_STAT_CASH_SPENT, ft);
screenCoords.y += LIST_ROW_HEIGHT * 2;
}
@ -1679,7 +1679,7 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<money32>(peep->PaidToEnter);
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_ENTRANCE_FEE, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_ENTRANCE_FEE, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
// Paid on rides
@ -1689,11 +1689,11 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<uint16_t>(peep->GuestNumRides);
if (peep->GuestNumRides != 1)
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_RIDE_PLURAL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_RIDE_PLURAL, ft);
}
else
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_RIDE, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_RIDE, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -1704,11 +1704,11 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<uint16_t>(peep->AmountOfFood);
if (peep->AmountOfFood != 1)
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_FOOD_PLURAL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_FOOD_PLURAL, ft);
}
else
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_FOOD, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_FOOD, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -1720,11 +1720,11 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<uint16_t>(peep->AmountOfDrinks);
if (peep->AmountOfDrinks != 1)
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_DRINK_PLURAL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_DRINK_PLURAL, ft);
}
else
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_DRINK, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_DRINK, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -1735,11 +1735,11 @@ void window_guest_finance_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<uint16_t>(peep->AmountOfSouvenirs);
if (peep->AmountOfSouvenirs != 1)
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_SOUVENIR_PLURAL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_SOUVENIR_PLURAL, ft);
}
else
{
gfx_draw_string_left(dpi, STR_GUEST_EXPENSES_SOUVENIR, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_EXPENSES_SOUVENIR, ft);
}
}
}
@ -1793,7 +1793,7 @@ void window_guest_thoughts_paint(rct_window* w, rct_drawpixelinfo* dpi)
+ ScreenCoordsXY{ window_guest_thoughts_widgets[WIDX_PAGE_BACKGROUND].left + 4,
window_guest_thoughts_widgets[WIDX_PAGE_BACKGROUND].top + 4 };
gfx_draw_string_left(dpi, STR_GUEST_RECENT_THOUGHTS_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUEST_RECENT_THOUGHTS_LABEL);
screenCoords.y += 10;
for (rct_peep_thought* thought = peep->Thoughts; thought < &peep->Thoughts[PEEP_MAX_THOUGHTS]; ++thought)
@ -1979,7 +1979,7 @@ void window_guest_inventory_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t maxY = w->windowPos.y + w->height - 22;
int32_t numItems = 0;
gfx_draw_string_left(dpi, STR_CARRYING, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CARRYING);
screenCoords.y += 10;
for (ShopItem item = ShopItem::Balloon; item < ShopItem::Count; item++)
@ -1996,7 +1996,7 @@ void window_guest_inventory_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (numItems == 0)
{
gfx_draw_string_left(dpi, STR_NOTHING, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NOTHING);
}
}
@ -2035,7 +2035,7 @@ void window_guest_debug_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<uint32_t>(peep->sprite_index);
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_SPRITE_INDEX, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_SPRITE_INDEX, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
{
@ -2043,7 +2043,7 @@ void window_guest_debug_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<int32_t>(peep->x);
ft.Add<int32_t>(peep->y);
ft.Add<int32_t>(peep->z);
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_POSITION, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_POSITION, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
{
@ -2072,7 +2072,7 @@ void window_guest_debug_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<int32_t>(peep->DestinationX);
ft.Add<int32_t>(peep->DestinationY);
ft.Add<int32_t>(peep->DestinationTolerance);
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_DEST, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_DEST, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
{
@ -2081,10 +2081,10 @@ void window_guest_debug_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<int32_t>(peep->PathfindGoal.y);
ft.Add<int32_t>(peep->PathfindGoal.z);
ft.Add<int32_t>(peep->PathfindGoal.direction);
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_PATHFIND_GOAL, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_GOAL, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_PATHFIND_HISTORY, nullptr, 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_HISTORY);
screenCoords.y += LIST_ROW_HEIGHT;
screenCoords.x += 10;
@ -2095,7 +2095,7 @@ void window_guest_debug_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<int32_t>(point.y);
ft.Add<int32_t>(point.z);
ft.Add<int32_t>(point.direction);
gfx_draw_string_left(dpi, STR_PEEP_DEBUG_PATHFIND_HISTORY_ITEM, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PEEP_DEBUG_PATHFIND_HISTORY_ITEM, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
screenCoords.x -= 10;

6
src/openrct2-ui/windows/GuestList.cpp
View File

@ -481,9 +481,9 @@ public:
screenCoords = windowPos + ScreenCoordsXY{ 4, widgets[WIDX_GUEST_LIST].bottom + 2 };
auto ft = Formatter();
ft.Add<int32_t>(static_cast<int32_t>(_guestList.size()));
gfx_draw_string_left(
&dpi, (_guestList.size() == 1 ? STR_FORMAT_NUM_GUESTS_SINGULAR : STR_FORMAT_NUM_GUESTS_PLURAL), ft.Data(),
COLOUR_BLACK, screenCoords);
DrawTextBasic(
&dpi, screenCoords, (_guestList.size() == 1 ? STR_FORMAT_NUM_GUESTS_SINGULAR : STR_FORMAT_NUM_GUESTS_PLURAL),
ft);
}
}

34
src/openrct2-ui/windows/InstallTrack.cpp
View File

@ -234,7 +234,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto trackName = _trackName.c_str();
auto ft = Formatter();
ft.Add<const char*>(trackName);
gfx_draw_string_left(dpi, STR_TRACK_DESIGN_NAME, ft.Data(), COLOUR_BLACK, screenPos - ScreenCoordsXY{ 1, 0 });
DrawTextBasic(dpi, screenPos - ScreenCoordsXY{ 1, 0 }, STR_TRACK_DESIGN_NAME, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -255,7 +255,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft.Add<rct_string_id>(GetRideTypeDescriptor(td6->type).Naming.Name);
}
gfx_draw_string_left(dpi, STR_TRACK_DESIGN_TYPE, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_DESIGN_TYPE, ft);
screenPos.y += LIST_ROW_HEIGHT + 4;
}
@ -264,21 +264,21 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
fixed32_2dp rating = td6->excitement * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
gfx_draw_string_left(dpi, STR_TRACK_LIST_EXCITEMENT_RATING, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_EXCITEMENT_RATING, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
{
fixed32_2dp rating = td6->intensity * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
gfx_draw_string_left(dpi, STR_TRACK_LIST_INTENSITY_RATING, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_INTENSITY_RATING, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
{
fixed32_2dp rating = td6->nausea * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
gfx_draw_string_left(dpi, STR_TRACK_LIST_NAUSEA_RATING, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_NAUSEA_RATING, ft);
screenPos.y += LIST_ROW_HEIGHT + 4;
}
@ -290,7 +290,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
uint16_t holes = td6->holes & 0x1F;
auto ft = Formatter();
ft.Add<uint16_t>(holes);
gfx_draw_string_left(dpi, STR_HOLES, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_HOLES, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
else
@ -300,7 +300,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
uint16_t speed = ((td6->max_speed << 16) * 9) >> 18;
auto ft = Formatter();
ft.Add<uint16_t>(speed);
gfx_draw_string_left(dpi, STR_MAX_SPEED, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_SPEED, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
// Average speed
@ -308,7 +308,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
uint16_t speed = ((td6->average_speed << 16) * 9) >> 18;
auto ft = Formatter();
ft.Add<uint16_t>(speed);
gfx_draw_string_left(dpi, STR_AVERAGE_SPEED, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_AVERAGE_SPEED, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
}
@ -328,7 +328,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t gForces = td6->max_positive_vertical_g * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
gfx_draw_string_left(dpi, STR_MAX_POSITIVE_VERTICAL_G, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_POSITIVE_VERTICAL_G, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
// Maximum negative vertical Gs
@ -336,7 +336,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t gForces = td6->max_negative_vertical_g * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
gfx_draw_string_left(dpi, STR_MAX_NEGATIVE_VERTICAL_G, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_NEGATIVE_VERTICAL_G, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
// Maximum lateral Gs
@ -344,7 +344,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t gForces = td6->max_lateral_g * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
gfx_draw_string_left(dpi, STR_MAX_LATERAL_G, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
if (td6->total_air_time != 0)
@ -353,7 +353,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
int32_t airTime = td6->total_air_time * 25;
auto ft = Formatter();
ft.Add<int32_t>(airTime);
gfx_draw_string_left(dpi, STR_TOTAL_AIR_TIME, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
}
@ -364,11 +364,11 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
uint16_t drops = td6->drops & 0x3F;
auto ft = Formatter();
ft.Add<uint16_t>(drops);
gfx_draw_string_left(dpi, STR_DROPS, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_DROPS, ft);
screenPos.y += LIST_ROW_HEIGHT;
// Drop height is multiplied by 0.75
gfx_draw_string_left(dpi, STR_HIGHEST_DROP_HEIGHT, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_HIGHEST_DROP_HEIGHT, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -380,7 +380,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Inversions
auto ft = Formatter();
ft.Add<uint16_t>(inversions);
gfx_draw_string_left(dpi, STR_INVERSIONS, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_INVERSIONS, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
}
@ -392,7 +392,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<uint16_t>(td6->space_required_x);
ft.Add<uint16_t>(td6->space_required_y);
gfx_draw_string_left(dpi, STR_TRACK_LIST_SPACE_REQUIRED, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -400,7 +400,7 @@ static void window_install_track_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<uint32_t>(td6->cost);
gfx_draw_string_left(dpi, STR_TRACK_LIST_COST_AROUND, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_COST_AROUND, ft);
}
}

12
src/openrct2-ui/windows/LoadSave.cpp
View File

@ -714,8 +714,9 @@ static void window_loadsave_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Draw name button indicator.
rct_widget sort_name_widget = window_loadsave_widgets[WIDX_SORT_NAME];
gfx_draw_string_left(
dpi, STR_NAME, &id, COLOUR_GREY, w->windowPos + ScreenCoordsXY{ sort_name_widget.left + 11, sort_name_widget.top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ sort_name_widget.left + 11, sort_name_widget.top + 1 }, STR_NAME, &id,
{ COLOUR_GREY });
// Date button text
if (gConfigGeneral.load_save_sort == Sort::DateAscending)
@ -726,8 +727,9 @@ static void window_loadsave_paint(rct_window* w, rct_drawpixelinfo* dpi)
id = STR_NONE;
rct_widget sort_date_widget = window_loadsave_widgets[WIDX_SORT_DATE];
gfx_draw_string_left(
dpi, STR_DATE, &id, COLOUR_GREY, w->windowPos + ScreenCoordsXY{ sort_date_widget.left + 5, sort_date_widget.top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ sort_date_widget.left + 5, sort_date_widget.top + 1 }, STR_DATE, &id,
{ COLOUR_GREY });
}
static void window_loadsave_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32_t scrollIndex)
@ -760,7 +762,7 @@ static void window_loadsave_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, i
{
auto ft = Formatter();
ft.Add<rct_string_id>(STR_RIGHTGUILLEMET);
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, { 0, y });
DrawTextBasic(dpi, { 0, y }, stringId, ft);
}
// Print filename

8
src/openrct2-ui/windows/Map.cpp
View File

@ -852,7 +852,7 @@ static void window_map_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
gfx_fill_rect(
dpi, { screenCoords + ScreenCoordsXY{ 0, 2 }, screenCoords + ScreenCoordsXY{ 6, 8 } }, RideKeyColours[i]);
gfx_draw_string_left(dpi, mapLabels[i], w, COLOUR_BLACK, screenCoords + ScreenCoordsXY{ LIST_ROW_HEIGHT, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ LIST_ROW_HEIGHT, 0 }, mapLabels[i], w);
screenCoords.y += LIST_ROW_HEIGHT;
if (i == 3)
{
@ -863,9 +863,9 @@ static void window_map_paint(rct_window* w, rct_drawpixelinfo* dpi)
}
else if (!WidgetIsActiveTool(w, WIDX_SET_LAND_RIGHTS))
{
gfx_draw_string_left(
dpi, STR_MAP_SIZE, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_MAP_SIZE_SPINNER].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_MAP_SIZE_SPINNER].top + 1 }, STR_MAP_SIZE, {},
{ w->colours[1] });
}
}

185
src/openrct2-ui/windows/MapGen.cpp
View File

@ -691,36 +691,34 @@ static void window_mapgen_base_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_mapgen_draw_tab_images(dpi, w);
const uint8_t textColour = w->colours[1];
const auto textColour = w->colours[1];
gfx_draw_string_left(
dpi, STR_MAP_SIZE, nullptr, textColour, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_MAP_SIZE].top + 1 });
gfx_draw_string_left(
dpi, STR_BASE_HEIGHT_LABEL, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_BASE_HEIGHT].top + 1 });
gfx_draw_string_left(
dpi, STR_WATER_LEVEL_LABEL, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_WATER_LEVEL].top + 1 });
gfx_draw_string_left(
dpi, STR_TERRAIN_LABEL, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_FLOOR_TEXTURE].top + 1 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_MAP_SIZE].top + 1 }, STR_MAP_SIZE, {}, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_BASE_HEIGHT].top + 1 }, STR_BASE_HEIGHT_LABEL, {},
{ textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
{ textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_FLOOR_TEXTURE].top + 1 }, STR_TERRAIN_LABEL, {}, { textColour });
// The practical map size is 2 lower than the technical map size
// This needs to be cast down to a uint16_t because that's what the STR_RESOLUTION_X_BY_Y string takes.
uint16_t mapSizeArgs[] = { static_cast<uint16_t>(_mapSize - 2), static_cast<uint16_t>(_mapSize - 2) };
gfx_draw_string_left(
dpi, STR_RESOLUTION_X_BY_Y, &mapSizeArgs, w->colours[1],
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_MAP_SIZE].left + 1, w->widgets[WIDX_MAP_SIZE].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_MAP_SIZE].left + 1, w->widgets[WIDX_MAP_SIZE].top + 1 },
STR_RESOLUTION_X_BY_Y, &mapSizeArgs, { w->colours[1] });
arg = (_baseHeight - 12) / 2;
gfx_draw_string_left(
dpi, STR_COMMA16, &arg, w->colours[1],
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_BASE_HEIGHT].left + 1, w->widgets[WIDX_BASE_HEIGHT].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_BASE_HEIGHT].left + 1, w->widgets[WIDX_BASE_HEIGHT].top + 1 },
STR_COMMA16, &arg, { w->colours[1] });
arg = (_waterLevel - 12) / 2;
gfx_draw_string_left(
dpi, STR_COMMA16, &arg, w->colours[1],
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_WATER_LEVEL].left + 1, w->widgets[WIDX_WATER_LEVEL].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_WATER_LEVEL].left + 1, w->widgets[WIDX_WATER_LEVEL].top + 1 },
STR_COMMA16, &arg, { w->colours[1] });
}
#pragma endregion
@ -1012,56 +1010,60 @@ static void window_mapgen_simplex_paint(rct_window* w, rct_drawpixelinfo* dpi)
const uint8_t textColour = w->colours[1];
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_LOW_, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_LOW].top + 1 });
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_HIGH, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_HIGH].top + 1 });
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_BASE_FREQUENCY, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 });
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_OCTAVES, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_OCTAVES].top + 1 });
gfx_draw_string_left(
dpi, STR_MAP_SIZE, nullptr, textColour, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_MAP_SIZE].top + 1 });
gfx_draw_string_left(
dpi, STR_WATER_LEVEL_LABEL, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_LOW].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_LOW_, {},
{ textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_HIGH].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_HIGH, {},
{ textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 },
STR_MAPGEN_SIMPLEX_NOISE_BASE_FREQUENCY, {}, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_OCTAVES].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_OCTAVES, {},
{ textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_MAP_SIZE].top + 1 }, STR_MAP_SIZE, {}, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
{ textColour });
gfx_draw_string_left(
dpi, STR_COMMA16, &_simplex_low, textColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_LOW].left + 1, w->widgets[WIDX_SIMPLEX_LOW].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &_simplex_high, textColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_HIGH].left + 1, w->widgets[WIDX_SIMPLEX_HIGH].top + 1 });
gfx_draw_string_left(
dpi, STR_WINDOW_OBJECTIVE_VALUE_RATING, &_simplex_base_freq, textColour,
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_LOW].left + 1, w->widgets[WIDX_SIMPLEX_LOW].top + 1 },
STR_COMMA16, &_simplex_low, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_HIGH].left + 1, w->widgets[WIDX_SIMPLEX_HIGH].top + 1 },
STR_COMMA16, &_simplex_high, { textColour });
DrawTextBasic(
dpi,
w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_BASE_FREQ].left + 1, w->widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &_simplex_octaves, textColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_OCTAVES].left + 1, w->widgets[WIDX_SIMPLEX_OCTAVES].top + 1 });
gfx_draw_string_left(
dpi, STR_TERRAIN_LABEL, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX].top + 1 });
gfx_draw_string_left(
dpi, STR_MAPGEN_OPTION_PLACE_TREES, nullptr, textColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_PLACE_TREES_CHECKBOX].top + 1 });
+ ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_BASE_FREQ].left + 1, w->widgets[WIDX_SIMPLEX_BASE_FREQ].top + 1 },
STR_WINDOW_OBJECTIVE_VALUE_RATING, &_simplex_base_freq, { textColour });
DrawTextBasic(
dpi,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_OCTAVES].left + 1, w->widgets[WIDX_SIMPLEX_OCTAVES].top + 1 },
STR_COMMA16, &_simplex_octaves, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_RANDOM_TERRAIN_CHECKBOX].top + 1 }, STR_TERRAIN_LABEL,
{}, { textColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_SIMPLEX_PLACE_TREES_CHECKBOX].top + 1 },
STR_MAPGEN_OPTION_PLACE_TREES, {}, { textColour });
// The practical map size is 2 lower than the technical map size.
// This needs to be cast down to a uint16_t because that's what the STR_RESOLUTION_X_BY_Y string takes.
uint16_t mapSizeArgs[] = { static_cast<uint16_t>(_mapSize - 2), static_cast<uint16_t>(_mapSize - 2) };
gfx_draw_string_left(
dpi, STR_RESOLUTION_X_BY_Y, &mapSizeArgs, textColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_MAP_SIZE].left + 1, w->widgets[WIDX_SIMPLEX_MAP_SIZE].top + 1 });
DrawTextBasic(
dpi,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_MAP_SIZE].left + 1, w->widgets[WIDX_SIMPLEX_MAP_SIZE].top + 1 },
STR_RESOLUTION_X_BY_Y, &mapSizeArgs, { textColour });
arg = (_waterLevel - 12) / 2;
gfx_draw_string_left(
dpi, STR_COMMA16, &arg, textColour,
DrawTextBasic(
dpi,
w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_WATER_LEVEL].left + 1, w->widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 });
+ ScreenCoordsXY{ w->widgets[WIDX_SIMPLEX_WATER_LEVEL].left + 1, w->widgets[WIDX_SIMPLEX_WATER_LEVEL].top + 1 },
STR_COMMA16, &arg, { textColour });
}
#pragma endregion
@ -1209,49 +1211,50 @@ static void window_mapgen_heightmap_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_mapgen_draw_tab_images(dpi, w);
const uint8_t enabledColour = w->colours[1];
const uint8_t disabledColour = enabledColour | COLOUR_FLAG_INSET;
const colour_t enabledColour = w->colours[1];
const colour_t disabledColour = enabledColour | COLOUR_FLAG_INSET;
// Smooth strength label and value
const uint8_t strengthColour = _heightmapSmoothMap ? enabledColour : disabledColour;
const colour_t strengthColour = _heightmapSmoothMap ? enabledColour : disabledColour;
int16_t strength = _heightmapSmoothStrength;
gfx_draw_string_left(
dpi, STR_MAPGEN_SMOOTH_STRENGTH, nullptr, strengthColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &strength, strengthColour,
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 }, STR_MAPGEN_SMOOTH_STRENGTH, {},
{ strengthColour });
DrawTextBasic(
dpi,
w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_STRENGTH].left + 1, w->widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 });
+ ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_STRENGTH].left + 1, w->widgets[WIDX_HEIGHTMAP_STRENGTH].top + 1 },
STR_COMMA16, &strength, { strengthColour });
// Low label and value
const uint8_t labelColour = _heightmapLoaded ? enabledColour : disabledColour;
const colour_t labelColour = _heightmapLoaded ? enabledColour : disabledColour;
int16_t low = _heightmapLow;
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_LOW_, nullptr, labelColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_LOW].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &low, labelColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_LOW].left + 1, w->widgets[WIDX_HEIGHTMAP_LOW].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_LOW].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_LOW_, {},
{ labelColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_LOW].left + 1, w->widgets[WIDX_HEIGHTMAP_LOW].top + 1 },
STR_COMMA16, &low, { labelColour });
// High label and value
int16_t high = _heightmapHigh;
gfx_draw_string_left(
dpi, STR_MAPGEN_SIMPLEX_NOISE_HIGH, nullptr, labelColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_HIGH].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &high, labelColour,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_HIGH].left + 1, w->widgets[WIDX_HEIGHTMAP_HIGH].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_HIGH].top + 1 }, STR_MAPGEN_SIMPLEX_NOISE_HIGH, {},
{ labelColour });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_HIGH].left + 1, w->widgets[WIDX_HEIGHTMAP_HIGH].top + 1 },
STR_COMMA16, &high, { labelColour });
// Water level label and value
int16_t waterLevel = _waterLevel;
gfx_draw_string_left(
dpi, STR_WATER_LEVEL_LABEL, nullptr, labelColour,
w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 });
gfx_draw_string_left(
dpi, STR_COMMA16, &waterLevel, labelColour,
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 5, w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 }, STR_WATER_LEVEL_LABEL, {},
{ labelColour });
DrawTextBasic(
dpi,
w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].left + 1,
w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 });
+ ScreenCoordsXY{ w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].left + 1, w->widgets[WIDX_HEIGHTMAP_WATER_LEVEL].top + 1 },
STR_COMMA16, &waterLevel, { labelColour });
}
#pragma endregion

12
src/openrct2-ui/windows/Multiplayer.cpp
View File

@ -434,21 +434,21 @@ static void window_multiplayer_information_paint(rct_window* w, rct_drawpixelinf
const utf8* providerName = network_get_server_provider_name();
if (!str_is_null_or_empty(providerName))
{
gfx_draw_string_left(dpi, STR_PROVIDER_NAME, static_cast<void*>(&providerName), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PROVIDER_NAME, static_cast<void*>(&providerName));
screenCoords.y += LIST_ROW_HEIGHT;
}
const utf8* providerEmail = network_get_server_provider_email();
if (!str_is_null_or_empty(providerEmail))
{
gfx_draw_string_left(dpi, STR_PROVIDER_EMAIL, static_cast<void*>(&providerEmail), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PROVIDER_EMAIL, static_cast<void*>(&providerEmail));
screenCoords.y += LIST_ROW_HEIGHT;
}
const utf8* providerWebsite = network_get_server_provider_website();
if (!str_is_null_or_empty(providerWebsite))
{
gfx_draw_string_left(dpi, STR_PROVIDER_WEBSITE, static_cast<void*>(&providerWebsite), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PROVIDER_WEBSITE, static_cast<void*>(&providerWebsite));
}
}
}
@ -561,7 +561,7 @@ static void window_multiplayer_players_paint(rct_window* w, rct_drawpixelinfo* d
// Number of players
stringId = w->no_list_items == 1 ? STR_MULTIPLAYER_PLAYER_COUNT : STR_MULTIPLAYER_PLAYER_COUNT_PLURAL;
auto screenCoords = w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_LIST].bottom + 2 };
gfx_draw_string_left(dpi, stringId, &w->no_list_items, w->colours[2], screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &w->no_list_items, { w->colours[2] });
}
static void window_multiplayer_players_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32_t scrollIndex)
@ -853,7 +853,7 @@ static void window_multiplayer_groups_paint(rct_window* w, rct_drawpixelinfo* dp
+ ScreenCoordsXY{ window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].left + 4,
window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].top + 4 };
gfx_draw_string_left(dpi, STR_DEFAULT_GROUP, nullptr, w->colours[2], screenPos);
DrawTextBasic(dpi, screenPos, STR_DEFAULT_GROUP, {}, { w->colours[2] });
screenPos.y += 20;
@ -909,7 +909,7 @@ static void window_multiplayer_groups_scrollpaint(rct_window* w, rct_drawpixelin
// Draw action name
auto ft = Formatter();
ft.Add<uint16_t>(network_get_action_name_string_id(i));
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, ft.Data(), COLOUR_BLACK, { 10, screenCoords.y });
DrawTextBasic(dpi, { 10, screenCoords.y }, STR_WINDOW_COLOUR_2_STRINGID, ft);
}
screenCoords.y += SCROLLABLE_ROW_HEIGHT;
}

10
src/openrct2-ui/windows/Network.cpp
View File

@ -383,13 +383,12 @@ static void window_network_information_paint(rct_window* w, rct_drawpixelinfo* d
// Received stats.
{
gfx_draw_string_left(dpi, STR_NETWORK_RECEIVE, nullptr, PALETTE_INDEX_10, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NETWORK_RECEIVE, {}, { PALETTE_INDEX_10 });
format_readable_speed(textBuffer, sizeof(textBuffer), _bytesInSec);
gfx_draw_string(dpi, textBuffer, PALETTE_INDEX_10, screenCoords + ScreenCoordsXY(70, 0));
gfx_draw_string_left(
dpi, STR_NETWORK_TOTAL_RECEIVED, nullptr, PALETTE_INDEX_10, screenCoords + ScreenCoordsXY{ 200, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 200, 0 }, STR_NETWORK_TOTAL_RECEIVED, {}, { PALETTE_INDEX_10 });
format_readable_size(
textBuffer, sizeof(textBuffer), _networkStats.bytesReceived[EnumValue(NetworkStatisticsGroup::Total)]);
@ -403,13 +402,12 @@ static void window_network_information_paint(rct_window* w, rct_drawpixelinfo* d
// Sent stats.
{
gfx_draw_string_left(dpi, STR_NETWORK_SEND, nullptr, PALETTE_INDEX_10, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NETWORK_SEND, {}, { PALETTE_INDEX_10 });
format_readable_speed(textBuffer, sizeof(textBuffer), _bytesOutSec);
gfx_draw_string(dpi, textBuffer, PALETTE_INDEX_10, screenCoords + ScreenCoordsXY(70, 0));
gfx_draw_string_left(
dpi, STR_NETWORK_TOTAL_SENT, nullptr, PALETTE_INDEX_10, screenCoords + ScreenCoordsXY{ 200, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 200, 0 }, STR_NETWORK_TOTAL_SENT, {}, { PALETTE_INDEX_10 });
format_readable_size(
textBuffer, sizeof(textBuffer), _networkStats.bytesSent[EnumValue(NetworkStatisticsGroup::Total)]);

10
src/openrct2-ui/windows/NewCampaign.cpp
View File

@ -374,20 +374,20 @@ static void window_new_campaign_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Number of weeks
rct_widget* spinnerWidget = &window_new_campaign_widgets[WIDX_WEEKS_SPINNER];
gfx_draw_string_left(
dpi, w->campaign.no_weeks == 1 ? STR_MARKETING_1_WEEK : STR_X_WEEKS, &w->campaign.no_weeks, w->colours[0],
w->windowPos + ScreenCoordsXY{ spinnerWidget->left + 1, spinnerWidget->top });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ spinnerWidget->left + 1, spinnerWidget->top },
w->campaign.no_weeks == 1 ? STR_MARKETING_1_WEEK : STR_X_WEEKS, &w->campaign.no_weeks, { w->colours[0] });
screenCoords = w->windowPos + ScreenCoordsXY{ 14, 60 };
// Price per week
money32 pricePerWeek = AdvertisingCampaignPricePerWeek[w->campaign.campaign_type];
gfx_draw_string_left(dpi, STR_MARKETING_COST_PER_WEEK, &pricePerWeek, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_MARKETING_COST_PER_WEEK, &pricePerWeek);
screenCoords.y += 13;
// Total price
money32 totalPrice = AdvertisingCampaignPricePerWeek[w->campaign.campaign_type] * w->campaign.no_weeks;
gfx_draw_string_left(dpi, STR_MARKETING_TOTAL_COST, &totalPrice, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_MARKETING_TOTAL_COST, &totalPrice);
}
void WindowCampaignRefreshRides()

2
src/openrct2-ui/windows/NewRide.cpp
View File

@ -936,7 +936,7 @@ static void window_new_ride_paint_ride_information(
break;
}
gfx_draw_string_left(dpi, designCountStringId, ft.Data(), COLOUR_BLACK, screenPos + ScreenCoordsXY{ 0, 51 });
DrawTextBasic(dpi, screenPos + ScreenCoordsXY{ 0, 51 }, designCountStringId, ft);
// Price
if (!(gParkFlags & PARK_FLAGS_NO_MONEY))

2
src/openrct2-ui/windows/News.cpp
View File

@ -243,7 +243,7 @@ static void window_news_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32
auto ft = Formatter();
ft.Add<rct_string_id>(DateDayNames[newsItem.Day - 1]);
ft.Add<rct_string_id>(DateGameMonthNames[date_get_month(newsItem.MonthYear)]);
gfx_draw_string_left(dpi, STR_NEWS_DATE_FORMAT, ft.Data(), COLOUR_WHITE, { 2, y });
DrawTextBasic(dpi, { 2, y }, STR_NEWS_DATE_FORMAT, ft, { COLOUR_WHITE });
}
// Item text
{

4
src/openrct2-ui/windows/ObjectLoadError.cpp
View File

@ -583,11 +583,11 @@ static void window_object_load_error_scrollpaint(rct_window* w, rct_drawpixelinf
// ... source game ...
rct_string_id sourceStringId = object_manager_get_source_game_string(_invalid_entries[i].GetSourceGame());
gfx_draw_string_left(dpi, sourceStringId, nullptr, COLOUR_DARK_GREEN, { SOURCE_COL_LEFT - 3, screenCoords.y });
DrawTextBasic(dpi, { SOURCE_COL_LEFT - 3, screenCoords.y }, sourceStringId, {}, { COLOUR_DARK_GREEN });
// ... and type
rct_string_id type = get_object_type_string(&_invalid_entries[i]);
gfx_draw_string_left(dpi, type, nullptr, COLOUR_DARK_GREEN, { TYPE_COL_LEFT - 3, screenCoords.y });
DrawTextBasic(dpi, { TYPE_COL_LEFT - 3, screenCoords.y }, type, {}, { COLOUR_DARK_GREEN });
}
}

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

@ -893,31 +893,31 @@ static void window_options_display_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_options_draw_tab_images(dpi, w);
gfx_draw_string_left(
dpi, STR_FULLSCREEN_MODE, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_FULLSCREEN].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_FULLSCREEN].top + 1 }, STR_FULLSCREEN_MODE,
w, { w->colours[1] });
// Disable resolution dropdown on "Windowed" and "Fullscreen (desktop)"
int32_t colour = w->colours[1];
colour_t colour = w->colours[1];
if (gConfigGeneral.fullscreen_mode != static_cast<int32_t>(OpenRCT2::Ui::FULLSCREEN_MODE::FULLSCREEN))
{
colour |= COLOUR_FLAG_INSET;
}
gfx_draw_string_left(
dpi, STR_DISPLAY_RESOLUTION, w, colour,
w->windowPos + ScreenCoordsXY{ 10 + 15, window_options_display_widgets[WIDX_RESOLUTION].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10 + 15, window_options_display_widgets[WIDX_RESOLUTION].top + 1 },
STR_DISPLAY_RESOLUTION, w, { colour });
gfx_draw_string_left(
dpi, STR_UI_SCALING_DESC, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_SCALE].top + 1 });
gfx_draw_string_left(
dpi, STR_DRAWING_ENGINE, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_DRAWING_ENGINE].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_SCALE].top + 1 }, STR_UI_SCALING_DESC, w,
{ w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_display_widgets[WIDX_DRAWING_ENGINE].top + 1 },
STR_DRAWING_ENGINE, w, { w->colours[1] });
int32_t scale = static_cast<int32_t>(gConfigGeneral.window_scale * 100);
gfx_draw_string_left(
dpi, STR_WINDOW_OBJECTIVE_VALUE_RATING, &scale, w->colours[1],
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SCALE].left + 1, w->widgets[WIDX_SCALE].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_SCALE].left + 1, w->widgets[WIDX_SCALE].top + 1 },
STR_WINDOW_OBJECTIVE_VALUE_RATING, &scale, { w->colours[1] });
colour = w->colours[1];
if (gConfigGeneral.drawing_engine == DrawingEngine::Software
@ -925,9 +925,9 @@ static void window_options_display_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
colour |= COLOUR_FLAG_INSET;
}
gfx_draw_string_left(
dpi, STR_SCALING_QUALITY, w, colour,
w->windowPos + ScreenCoordsXY{ 25, window_options_display_widgets[WIDX_SCALE_QUALITY].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 25, window_options_display_widgets[WIDX_SCALE_QUALITY].top + 1 },
STR_SCALING_QUALITY, w, { colour });
}
#pragma region Rendering Tab
@ -1328,24 +1328,24 @@ static void window_options_culture_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_options_draw_tab_images(dpi, w);
gfx_draw_string_left(
dpi, STR_OPTIONS_LANGUAGE, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_LANGUAGE].top + 1 });
gfx_draw_string_left(
dpi, STR_CURRENCY, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_CURRENCY].top + 1 });
gfx_draw_string_left(
dpi, STR_DISTANCE_AND_SPEED, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_DISTANCE].top + 1 });
gfx_draw_string_left(
dpi, STR_TEMPERATURE, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_TEMPERATURE].top + 1 });
gfx_draw_string_left(
dpi, STR_HEIGHT_LABELS, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_HEIGHT_LABELS].top + 1 });
gfx_draw_string_left(
dpi, STR_DATE_FORMAT, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_DATE_FORMAT].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_LANGUAGE].top + 1 }, STR_OPTIONS_LANGUAGE,
w, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_CURRENCY].top + 1 }, STR_CURRENCY, w,
{ w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_DISTANCE].top + 1 }, STR_DISTANCE_AND_SPEED,
w, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_TEMPERATURE].top + 1 }, STR_TEMPERATURE, w,
{ w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_HEIGHT_LABELS].top + 1 }, STR_HEIGHT_LABELS,
w, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_culture_widgets[WIDX_DATE_FORMAT].top + 1 }, STR_DATE_FORMAT, w,
{ w->colours[1] });
}
#pragma region Audio Tab
@ -1744,13 +1744,13 @@ static void window_options_controls_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_options_draw_tab_images(dpi, w);
gfx_draw_string_left(
dpi, STR_SHOW_TOOLBAR_BUTTONS_FOR, w, w->colours[1],
w->windowPos
+ ScreenCoordsXY{ 10, window_options_controls_and_interface_widgets[WIDX_TOOLBAR_BUTTONS_GROUP].top + 15 });
gfx_draw_string_left(
dpi, STR_THEMES_LABEL_CURRENT_THEME, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_controls_and_interface_widgets[WIDX_THEMES].top + 1 });
DrawTextBasic(
dpi,
w->windowPos + ScreenCoordsXY{ 10, window_options_controls_and_interface_widgets[WIDX_TOOLBAR_BUTTONS_GROUP].top + 15 },
STR_SHOW_TOOLBAR_BUTTONS_FOR, w, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_controls_and_interface_widgets[WIDX_THEMES].top + 1 },
STR_THEMES_LABEL_CURRENT_THEME, {}, { w->colours[1] });
}
#pragma region Miscellaneous Tab
@ -1945,15 +1945,15 @@ static void window_options_misc_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_options_draw_tab_images(dpi, w);
gfx_draw_string_left(
dpi, STR_TITLE_SEQUENCE, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_TITLE_SEQUENCE].top + 1 });
gfx_draw_string_left(
dpi, STR_OPTIONS_SCENARIO_GROUPING, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_SCENARIO_GROUPING].top + 1 });
gfx_draw_string_left(
dpi, STR_DEFAULT_INSPECTION_INTERVAL, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_DEFAULT_INSPECTION_INTERVAL].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_TITLE_SEQUENCE].top + 1 }, STR_TITLE_SEQUENCE,
w, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_SCENARIO_GROUPING].top + 1 },
STR_OPTIONS_SCENARIO_GROUPING, {}, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_options_misc_widgets[WIDX_DEFAULT_INSPECTION_INTERVAL].top + 1 },
STR_DEFAULT_INSPECTION_INTERVAL, w, { w->colours[1] });
}
#pragma region Advanced Tab
@ -2111,21 +2111,23 @@ static void window_options_advanced_paint(rct_window* w, rct_drawpixelinfo* dpi)
WindowDrawWidgets(w, dpi);
window_options_draw_tab_images(dpi, w);
gfx_draw_string_left(
dpi, STR_OPTIONS_AUTOSAVE_FREQUENCY_LABEL, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 24, window_options_advanced_widgets[WIDX_AUTOSAVE].top + 1 });
gfx_draw_string_left(
dpi, window_options_autosave_names[gConfigGeneral.autosave_frequency], nullptr, w->colours[1],
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 24, window_options_advanced_widgets[WIDX_AUTOSAVE].top + 1 },
STR_OPTIONS_AUTOSAVE_FREQUENCY_LABEL, w, { w->colours[1] });
DrawTextBasic(
dpi,
w->windowPos
+ ScreenCoordsXY{ window_options_advanced_widgets[WIDX_AUTOSAVE].left + 1,
window_options_advanced_widgets[WIDX_AUTOSAVE].top });
gfx_draw_string_left(
dpi, STR_AUTOSAVE_AMOUNT, w, w->colours[1],
w->windowPos + ScreenCoordsXY{ 24, window_options_advanced_widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 });
window_options_advanced_widgets[WIDX_AUTOSAVE].top },
window_options_autosave_names[gConfigGeneral.autosave_frequency], {}, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 24, window_options_advanced_widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 },
STR_AUTOSAVE_AMOUNT, w, { w->colours[1] });
int32_t autosavesToKeep = static_cast<int32_t>(gConfigGeneral.autosave_amount);
gfx_draw_string_left(
dpi, STR_WINDOW_OBJECTIVE_VALUE_GUEST_COUNT, &autosavesToKeep, w->colours[1],
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_AUTOSAVE_AMOUNT].left + 1, w->widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 });
DrawTextBasic(
dpi,
w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_AUTOSAVE_AMOUNT].left + 1, w->widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 },
STR_WINDOW_OBJECTIVE_VALUE_GUEST_COUNT, &autosavesToKeep, { w->colours[1] });
auto ft = Formatter();
ft.Add<utf8*>(Platform::StrDecompToPrecomp(gConfigGeneral.rct1_path));

27
src/openrct2-ui/windows/Park.cpp
View File

@ -898,9 +898,7 @@ static void window_park_rating_paint(rct_window* w, rct_drawpixelinfo* dpi)
rct_widget* widget = &window_park_rating_widgets[WIDX_PAGE_BACKGROUND];
// Current value
gfx_draw_string_left(
dpi, STR_PARK_RATING_LABEL, &gParkRating, COLOUR_BLACK,
screenPos + ScreenCoordsXY{ widget->left + 3, widget->top + 2 });
DrawTextBasic(dpi, screenPos + ScreenCoordsXY{ widget->left + 3, widget->top + 2 }, STR_PARK_RATING_LABEL, &gParkRating);
// Graph border
gfx_fill_rect_inset(
@ -1033,9 +1031,8 @@ static void window_park_guests_paint(rct_window* w, rct_drawpixelinfo* dpi)
rct_widget* widget = &window_park_guests_widgets[WIDX_PAGE_BACKGROUND];
// Current value
gfx_draw_string_left(
dpi, STR_GUESTS_IN_PARK_LABEL, &gNumGuestsInPark, COLOUR_BLACK,
screenPos + ScreenCoordsXY{ widget->left + 3, widget->top + 2 });
DrawTextBasic(
dpi, screenPos + ScreenCoordsXY{ widget->left + 3, widget->top + 2 }, STR_GUESTS_IN_PARK_LABEL, &gNumGuestsInPark);
// Graph border
gfx_fill_rect_inset(
@ -1180,12 +1177,12 @@ static void window_park_price_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_PAGE_BACKGROUND].left + 4, w->widgets[WIDX_PAGE_BACKGROUND].top + 30 };
gfx_draw_string_left(dpi, STR_INCOME_FROM_ADMISSIONS, &gTotalIncomeFromAdmissions, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INCOME_FROM_ADMISSIONS, &gTotalIncomeFromAdmissions);
money32 parkEntranceFee = park_get_entrance_fee();
auto stringId = parkEntranceFee == 0 ? STR_FREE : STR_BOTTOM_TOOLBAR_CASH;
screenCoords = w->windowPos + ScreenCoordsXY{ w->widgets[WIDX_PRICE].left + 1, w->widgets[WIDX_PRICE].top + 1 };
gfx_draw_string_left(dpi, stringId, &parkEntranceFee, w->colours[1], screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &parkEntranceFee, { w->colours[1] });
}
#pragma endregion
@ -1288,7 +1285,7 @@ static void window_park_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
}
auto ft = Formatter();
ft.Add<uint32_t>(parkSize);
gfx_draw_string_left(dpi, stringIndex, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringIndex, ft);
screenCoords.y += LIST_ROW_HEIGHT;
// Draw number of rides / attractions
@ -1296,7 +1293,7 @@ static void window_park_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
ft = Formatter();
ft.Add<uint32_t>(w->list_information_type);
gfx_draw_string_left(dpi, STR_NUMBER_OF_RIDES_LABEL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NUMBER_OF_RIDES_LABEL, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
@ -1305,18 +1302,18 @@ static void window_park_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
ft = Formatter();
ft.Add<uint32_t>(w->numberOfStaff);
gfx_draw_string_left(dpi, STR_STAFF_LABEL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_LABEL, ft);
}
screenCoords.y += LIST_ROW_HEIGHT;
// Draw number of guests in park
ft = Formatter();
ft.Add<uint32_t>(gNumGuestsInPark);
gfx_draw_string_left(dpi, STR_GUESTS_IN_PARK_LABEL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_GUESTS_IN_PARK_LABEL, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint32_t>(gTotalAdmissions);
gfx_draw_string_left(dpi, STR_TOTAL_ADMISSIONS, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TOTAL_ADMISSIONS, ft);
}
#pragma endregion
@ -1466,7 +1463,7 @@ static void window_park_objective_paint(rct_window* w, rct_drawpixelinfo* dpi)
screenCoords.y += 5;
// Your objective:
gfx_draw_string_left(dpi, STR_OBJECTIVE_LABEL, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_OBJECTIVE_LABEL);
screenCoords.y += LIST_ROW_HEIGHT;
// Objective
@ -1631,7 +1628,7 @@ static void window_park_awards_paint(rct_window* w, rct_drawpixelinfo* dpi)
}
if (count == 0)
gfx_draw_string_left(dpi, STR_NO_RECENT_AWARDS, nullptr, COLOUR_BLACK, screenCoords + ScreenCoordsXY{ 6, 6 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 6, 6 }, STR_NO_RECENT_AWARDS);
}
#pragma endregion

6
src/openrct2-ui/windows/Player.cpp
View File

@ -346,7 +346,7 @@ void window_player_overview_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<rct_string_id>(STR_PING);
gfx_draw_string_left(dpi, STR_WINDOW_COLOUR_2_STRINGID, ft.Data(), 0, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft);
char ping[64];
snprintf(ping, 64, "%d ms", network_get_player_ping(player));
gfx_draw_string(dpi, ping, w->colours[2], screenCoords + ScreenCoordsXY(30, 0));
@ -513,13 +513,13 @@ void window_player_statistics_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<uint32_t>(network_get_player_commands_ran(player));
gfx_draw_string_left(dpi, STR_COMMANDS_RAN, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_COMMANDS_RAN, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint32_t>(network_get_player_money_spent(player));
gfx_draw_string_left(dpi, STR_MONEY_SPENT, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_MONEY_SPENT, ft);
}
static void window_player_set_page(rct_window* w, int32_t page)

7
src/openrct2-ui/windows/Research.cpp
View File

@ -309,7 +309,7 @@ void window_research_development_page_paint(rct_window* w, rct_drawpixelinfo* dp
{
auto ft = Formatter();
ft.Add<rct_string_id>(STR_RESEARCH_STAGE_UNKNOWN);
gfx_draw_string_left(dpi, STR_RESEARCH_EXPECTED_LABEL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft);
}
}
else
@ -362,7 +362,7 @@ void window_research_development_page_paint(rct_window* w, rct_drawpixelinfo* dp
{
ft.Add<rct_string_id>(STR_RESEARCH_STAGE_UNKNOWN);
}
gfx_draw_string_left(dpi, STR_RESEARCH_EXPECTED_LABEL, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft);
}
// Last development
@ -562,8 +562,7 @@ void window_research_funding_page_paint(rct_window* w, rct_drawpixelinfo* dpi, r
int32_t currentResearchLevel = gResearchFundingLevel;
money32 currentResearchCostPerWeek = research_cost_table[currentResearchLevel];
gfx_draw_string_left(
dpi, STR_RESEARCH_COST_PER_MONTH, &currentResearchCostPerWeek, COLOUR_BLACK, w->windowPos + ScreenCoordsXY{ 10, 77 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 10, 77 }, STR_RESEARCH_COST_PER_MONTH, &currentResearchCostPerWeek);
}
#pragma endregion

95
src/openrct2-ui/windows/Ride.cpp
View File

@ -2952,19 +2952,19 @@ static void window_ride_vehicle_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto screenCoords = w->windowPos + ScreenCoordsXY{ 8, 64 };
// Description
screenCoords.y += gfx_draw_string_left_wrapped(
screenCoords.y += gfx_draw_string_centred_wrapped(
dpi, &rideEntry->naming.Description, screenCoords, 300, STR_BLACK_STRING, COLOUR_BLACK);
screenCoords.y += 2;
// Capacity
gfx_draw_string_left(dpi, STR_CAPACITY, &rideEntry->capacity, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CAPACITY, &rideEntry->capacity, COLOUR_BLACK);
// Excitement Factor
auto factor = static_cast<int16_t>(rideEntry->excitement_multiplier);
if (factor > 0)
{
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_EXCITEMENT_FACTOR, &factor, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_EXCITEMENT_FACTOR, &factor, COLOUR_BLACK);
}
// Intensity Factor
@ -2977,7 +2977,7 @@ static void window_ride_vehicle_paint(rct_window* w, rct_drawpixelinfo* dpi)
else
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_INTENSITY_FACTOR, &factor, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INTENSITY_FACTOR, &factor, COLOUR_BLACK);
if (lineHeight != 10)
screenCoords.x -= 150;
@ -2988,7 +2988,7 @@ static void window_ride_vehicle_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (factor > 0)
{
screenCoords.y += LIST_ROW_HEIGHT;
gfx_draw_string_left(dpi, STR_NAUSEA_FACTOR, &factor, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NAUSEA_FACTOR, &factor, COLOUR_BLACK);
}
}
@ -3684,9 +3684,9 @@ static void window_ride_operating_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (ride->IsBlockSectioned())
{
auto blockSections = ride->num_block_brakes + ride->num_stations;
gfx_draw_string_left(
dpi, STR_BLOCK_SECTIONS, &blockSections, COLOUR_BLACK,
w->windowPos + ScreenCoordsXY{ 21, ride->mode == RideMode::PoweredLaunchBlockSectioned ? 89 : 61 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 21, ride->mode == RideMode::PoweredLaunchBlockSectioned ? 89 : 61 },
STR_BLOCK_SECTIONS, &blockSections, COLOUR_BLACK);
}
}
@ -4079,20 +4079,20 @@ static void window_ride_maintenance_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Inspection label
widget = &window_ride_maintenance_widgets[WIDX_INSPECTION_INTERVAL];
screenCoords = w->windowPos + ScreenCoordsXY{ 4, widget->top + 1 };
gfx_draw_string_left(dpi, STR_INSPECTION, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INSPECTION);
// Reliability
widget = &window_ride_maintenance_widgets[WIDX_PAGE_BACKGROUND];
screenCoords = w->windowPos + ScreenCoordsXY{ widget->left + 4, widget->top + 4 };
uint16_t reliability = ride->reliability_percentage;
gfx_draw_string_left(dpi, STR_RELIABILITY_LABEL_1757, &reliability, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_RELIABILITY_LABEL_1757, &reliability);
window_ride_maintenance_draw_bar(
w, dpi, screenCoords.x + 103, screenCoords.y, std::max<int32_t>(10, reliability), COLOUR_BRIGHT_GREEN);
screenCoords.y += 11;
uint16_t downTime = ride->downtime;
gfx_draw_string_left(dpi, STR_DOWN_TIME_LABEL_1889, &downTime, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_DOWN_TIME_LABEL_1889, &downTime);
window_ride_maintenance_draw_bar(w, dpi, screenCoords.x + 103, screenCoords.y, downTime, COLOUR_BRIGHT_RED);
screenCoords.y += 26;
@ -4108,7 +4108,7 @@ static void window_ride_maintenance_paint(rct_window* w, rct_drawpixelinfo* dpi)
else
stringId = STR_TIME_SINCE_LAST_INSPECTION_MORE_THAN_4_HOURS;
gfx_draw_string_left(dpi, stringId, &lastInspection, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &lastInspection);
screenCoords.y += 12;
// Last / current breakdown
@ -4117,7 +4117,7 @@ static void window_ride_maintenance_paint(rct_window* w, rct_drawpixelinfo* dpi)
stringId = (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) ? STR_CURRENT_BREAKDOWN : STR_LAST_BREAKDOWN;
rct_string_id breakdownMessage = RideBreakdownReasonNames[ride->breakdown_reason];
gfx_draw_string_left(dpi, stringId, &breakdownMessage, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &breakdownMessage);
screenCoords.y += 10;
// Mechanic status
@ -4155,7 +4155,8 @@ static void window_ride_maintenance_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
if (stringId == STR_CALLING_MECHANIC || stringId == STR_NO_MECHANICS_ARE_HIRED_MESSAGE)
{
gfx_draw_string_left_wrapped(dpi, nullptr, screenCoords + ScreenCoordsXY{ 4, 0 }, 280, stringId, COLOUR_BLACK);
gfx_draw_string_centred_wrapped(
dpi, nullptr, screenCoords + ScreenCoordsXY{ 4, 0 }, 280, stringId, COLOUR_BLACK);
}
else
{
@ -4164,7 +4165,7 @@ static void window_ride_maintenance_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
staff->FormatNameTo(ft);
gfx_draw_string_left_wrapped(
gfx_draw_string_centred_wrapped(
dpi, ft.Data(), screenCoords + ScreenCoordsXY{ 4, 0 }, 280, stringId, COLOUR_BLACK);
}
}
@ -5604,7 +5605,7 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
ft.Add<rct_string_id>(ratingName);
rct_string_id stringId = ride->excitement == RIDE_RATING_UNDEFINED ? STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE
: STR_EXCITEMENT_RATING;
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT;
// Intensity
@ -5619,7 +5620,7 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
else if (ride->intensity >= RIDE_RATING(10, 00))
stringId = STR_INTENSITY_RATING_RED;
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT;
// Nausea
@ -5628,7 +5629,7 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
ft.Add<uint32_t>(ride->nausea);
ft.Add<rct_string_id>(ratingName);
stringId = ride->excitement == RIDE_RATING_UNDEFINED ? STR_NAUSEA_RATING_NOT_YET_AVAILABLE : STR_NAUSEA_RATING;
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += 2 * LIST_ROW_HEIGHT;
// Horizontal rule
@ -5642,19 +5643,19 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
{
// Holes
holes = ride->holes;
gfx_draw_string_left(dpi, STR_HOLES, &holes, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_HOLES, &holes);
screenCoords.y += LIST_ROW_HEIGHT;
}
else
{
// Max speed
maxSpeed = (ride->max_speed * 9) >> 18;
gfx_draw_string_left(dpi, STR_MAX_SPEED, &maxSpeed, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_MAX_SPEED, &maxSpeed);
screenCoords.y += LIST_ROW_HEIGHT;
// Average speed
averageSpeed = (ride->average_speed * 9) >> 18;
gfx_draw_string_left(dpi, STR_AVERAGE_SPEED, &averageSpeed, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_AVERAGE_SPEED, &averageSpeed);
screenCoords.y += LIST_ROW_HEIGHT;
// Ride time
@ -5738,25 +5739,25 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
maxPositiveVerticalGs = ride->max_positive_vertical_g;
stringId = maxPositiveVerticalGs >= RIDE_G_FORCES_RED_POS_VERTICAL ? STR_MAX_POSITIVE_VERTICAL_G_RED
: STR_MAX_POSITIVE_VERTICAL_G;
gfx_draw_string_left(dpi, stringId, &maxPositiveVerticalGs, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &maxPositiveVerticalGs);
screenCoords.y += LIST_ROW_HEIGHT;
// Max. negative vertical G's
maxNegativeVerticalGs = ride->max_negative_vertical_g;
stringId = maxNegativeVerticalGs <= RIDE_G_FORCES_RED_NEG_VERTICAL ? STR_MAX_NEGATIVE_VERTICAL_G_RED
: STR_MAX_NEGATIVE_VERTICAL_G;
gfx_draw_string_left(dpi, stringId, &maxNegativeVerticalGs, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &maxNegativeVerticalGs);
screenCoords.y += LIST_ROW_HEIGHT;
// Max lateral G's
maxLateralGs = ride->max_lateral_g;
stringId = maxLateralGs >= RIDE_G_FORCES_RED_LATERAL ? STR_MAX_LATERAL_G_RED : STR_MAX_LATERAL_G;
gfx_draw_string_left(dpi, stringId, &maxLateralGs, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &maxLateralGs);
screenCoords.y += LIST_ROW_HEIGHT;
// Total 'air' time
totalAirTime = ride->total_air_time * 3;
gfx_draw_string_left(dpi, STR_TOTAL_AIR_TIME, &totalAirTime, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TOTAL_AIR_TIME, &totalAirTime);
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -5764,12 +5765,12 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
{
// Drops
drops = ride->drops & 0x3F;
gfx_draw_string_left(dpi, STR_DROPS, &drops, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_DROPS, &drops);
screenCoords.y += LIST_ROW_HEIGHT;
// Highest drop height
highestDropHeight = (ride->highest_drop_height * 3) / 4;
gfx_draw_string_left(dpi, STR_HIGHEST_DROP_HEIGHT, &highestDropHeight, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_HIGHEST_DROP_HEIGHT, &highestDropHeight);
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -5779,7 +5780,7 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
inversions = ride->inversions;
if (inversions != 0)
{
gfx_draw_string_left(dpi, STR_INVERSIONS, &inversions, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INVERSIONS, &inversions);
screenCoords.y += LIST_ROW_HEIGHT;
}
}
@ -5787,7 +5788,7 @@ static void window_ride_measurements_paint(rct_window* w, rct_drawpixelinfo* dpi
}
else
{
gfx_draw_string_left(dpi, STR_NO_TEST_RESULTS_YET, nullptr, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_NO_TEST_RESULTS_YET);
}
}
}
@ -6120,7 +6121,7 @@ static void window_ride_graphs_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi
if (listType == GRAPH_ALTITUDE)
scaled_yUnit /= 2;
gfx_draw_string_left(dpi, stringID, &scaled_yUnit, COLOUR_BLACK, { w->scrolls[0].h_left + 1, y - 4 });
DrawTextBasic(dpi, { w->scrolls[0].h_left + 1, y - 4 }, stringID, &scaled_yUnit);
}
// Time marks
@ -6128,7 +6129,7 @@ static void window_ride_graphs_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi
for (int32_t x = 0; x < dpi->x + dpi->width; x += 80)
{
if (x + 80 >= dpi->x)
gfx_draw_string_left(dpi, STR_RIDE_STATS_TIME, &time, COLOUR_BLACK, { x + 2, 1 });
DrawTextBasic(dpi, { x + 2, 1 }, STR_RIDE_STATS_TIME, &time);
time += 5;
}
@ -6682,7 +6683,7 @@ static void window_ride_income_paint(rct_window* w, rct_drawpixelinfo* dpi)
stringId = STR_LOSS_PER_ITEM_SOLD;
}
gfx_draw_string_left(dpi, stringId, &profit, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &profit);
}
screenCoords.y += 44;
@ -6703,33 +6704,33 @@ static void window_ride_income_paint(rct_window* w, rct_drawpixelinfo* dpi)
stringId = STR_LOSS_PER_ITEM_SOLD;
}
gfx_draw_string_left(dpi, stringId, &profit, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &profit);
}
screenCoords.y += 18;
// Income per hour
if (ride->income_per_hour != MONEY32_UNDEFINED)
{
gfx_draw_string_left(dpi, STR_INCOME_PER_HOUR, &ride->income_per_hour, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_INCOME_PER_HOUR, &ride->income_per_hour);
screenCoords.y += LIST_ROW_HEIGHT;
}
// Running cost per hour
costPerHour = ride->upkeep_cost * 16;
stringId = ride->upkeep_cost == MONEY16_UNDEFINED ? STR_RUNNING_COST_UNKNOWN : STR_RUNNING_COST_PER_HOUR;
gfx_draw_string_left(dpi, stringId, &costPerHour, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &costPerHour);
screenCoords.y += LIST_ROW_HEIGHT;
// Profit per hour
if (ride->profit != MONEY32_UNDEFINED)
{
gfx_draw_string_left(dpi, STR_PROFIT_PER_HOUR, &ride->profit, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_PROFIT_PER_HOUR, &ride->profit);
screenCoords.y += LIST_ROW_HEIGHT;
}
screenCoords.y += 5;
// Total profit
gfx_draw_string_left(dpi, STR_TOTAL_PROFIT, &ride->total_profit, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TOTAL_PROFIT, &ride->total_profit);
}
#pragma endregion
@ -6881,13 +6882,13 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (ride->IsRide())
{
int16_t customersOnRide = ride->num_riders;
gfx_draw_string_left(dpi, STR_CUSTOMERS_ON_RIDE, &customersOnRide, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CUSTOMERS_ON_RIDE, &customersOnRide);
screenCoords.y += LIST_ROW_HEIGHT;
}
// Customers per hour
customersPerHour = ride_customers_per_hour(ride);
gfx_draw_string_left(dpi, STR_CUSTOMERS_PER_HOUR, &customersPerHour, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_CUSTOMERS_PER_HOUR, &customersPerHour);
screenCoords.y += LIST_ROW_HEIGHT;
// Popularity
@ -6901,7 +6902,7 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
stringId = STR_POPULARITY_PERCENT;
popularity *= 4;
}
gfx_draw_string_left(dpi, stringId, &popularity, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &popularity);
screenCoords.y += LIST_ROW_HEIGHT;
// Satisfaction
@ -6915,7 +6916,7 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
stringId = STR_SATISFACTION_PERCENT;
satisfaction *= 5;
}
gfx_draw_string_left(dpi, stringId, &satisfaction, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &satisfaction);
screenCoords.y += LIST_ROW_HEIGHT;
// Queue time
@ -6923,7 +6924,7 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
queueTime = ride->GetMaxQueueTime();
stringId = queueTime == 1 ? STR_QUEUE_TIME_MINUTE : STR_QUEUE_TIME_MINUTES;
screenCoords.y += gfx_draw_string_left_wrapped(dpi, &queueTime, screenCoords, 308, stringId, COLOUR_BLACK);
screenCoords.y += gfx_draw_string_centred_wrapped(dpi, &queueTime, screenCoords, 308, stringId, COLOUR_BLACK);
screenCoords.y += 5;
}
@ -6934,7 +6935,7 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<rct_string_id>(GetShopItemDescriptor(shopItem).Naming.Plural);
ft.Add<uint32_t>(ride->no_primary_items_sold);
gfx_draw_string_left(dpi, STR_ITEMS_SOLD, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_ITEMS_SOLD, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
@ -6946,19 +6947,19 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<rct_string_id>(GetShopItemDescriptor(shopItem).Naming.Plural);
ft.Add<uint32_t>(ride->no_secondary_items_sold);
gfx_draw_string_left(dpi, STR_ITEMS_SOLD, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_ITEMS_SOLD, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
// Total customers
gfx_draw_string_left(dpi, STR_TOTAL_CUSTOMERS, &ride->total_customers, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TOTAL_CUSTOMERS, &ride->total_customers);
screenCoords.y += LIST_ROW_HEIGHT;
// Guests favourite
if (ride->IsRide())
{
stringId = ride->guests_favourite == 1 ? STR_FAVOURITE_RIDE_OF_GUEST : STR_FAVOURITE_RIDE_OF_GUESTS;
gfx_draw_string_left(dpi, stringId, &ride->guests_favourite, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &ride->guests_favourite);
screenCoords.y += LIST_ROW_HEIGHT;
}
screenCoords.y += 2;
@ -6967,7 +6968,7 @@ static void window_ride_customer_paint(rct_window* w, rct_drawpixelinfo* dpi)
// If the ride has a build date that is in the future, show it as built this year.
int16_t age = std::max(date_get_year(ride->GetAge()), 0);
stringId = age == 0 ? STR_BUILT_THIS_YEAR : age == 1 ? STR_BUILT_LAST_YEAR : STR_BUILT_YEARS_AGO;
gfx_draw_string_left(dpi, stringId, &age, COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, stringId, &age);
}
#pragma endregion

6
src/openrct2-ui/windows/RideList.cpp
View File

@ -560,9 +560,9 @@ static void window_ride_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
window_ride_list_draw_tab_images(dpi, w);
// Draw number of attractions on bottom
gfx_draw_string_left(
dpi, ride_list_statusbar_count_strings[w->page], &w->no_list_items, COLOUR_BLACK,
w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_LIST].bottom + 2 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_LIST].bottom + 2 }, ride_list_statusbar_count_strings[w->page],
&w->no_list_items);
}
/**

6
src/openrct2-ui/windows/ScenarioSelect.cpp
View File

@ -483,9 +483,9 @@ static void window_scenarioselect_paint(rct_window* w, rct_drawpixelinfo* dpi)
shorten_path(path, sizeof(path), scenario->path, w->width - 6);
const utf8* pathPtr = path;
gfx_draw_string_left(
dpi, STR_STRING, static_cast<void*>(&pathPtr), w->colours[1],
w->windowPos + ScreenCoordsXY{ 3, w->height - 3 - 11 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 3, w->height - 3 - 11 }, STR_STRING, static_cast<void*>(&pathPtr),
{ w->colours[1] });
}
// Scenario name

18
src/openrct2-ui/windows/ServerList.cpp
View File

@ -400,20 +400,20 @@ static void window_server_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
WindowDrawWidgets(w, dpi);
gfx_draw_string_left(
dpi, STR_PLAYER_NAME, nullptr, COLOUR_WHITE,
w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PLAYER_NAME_INPUT].top });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PLAYER_NAME_INPUT].top }, STR_PLAYER_NAME, nullptr,
{ COLOUR_WHITE });
// Draw version number
std::string version = network_get_version();
const char* versionCStr = version.c_str();
gfx_draw_string_left(
dpi, STR_NETWORK_VERSION, static_cast<void*>(&versionCStr), COLOUR_WHITE,
w->windowPos + ScreenCoordsXY{ 324, w->widgets[WIDX_START_SERVER].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 324, w->widgets[WIDX_START_SERVER].top + 1 }, STR_NETWORK_VERSION,
static_cast<void*>(&versionCStr), { COLOUR_WHITE });
gfx_draw_string_left(
dpi, _statusText, static_cast<void*>(&_numPlayersOnline), COLOUR_WHITE,
w->windowPos + ScreenCoordsXY{ 8, w->height - 15 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 8, w->height - 15 }, _statusText, static_cast<void*>(&_numPlayersOnline),
{ COLOUR_WHITE });
}
static void window_server_list_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32_t scrollIndex)

27
src/openrct2-ui/windows/ServerStart.cpp
View File

@ -319,20 +319,19 @@ static void window_server_start_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
WindowDrawWidgets(w, dpi);
gfx_draw_string_left(
dpi, STR_PORT, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PORT_INPUT].top });
gfx_draw_string_left(
dpi, STR_SERVER_NAME, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_NAME_INPUT].top });
gfx_draw_string_left(
dpi, STR_SERVER_DESCRIPTION, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_DESCRIPTION_INPUT].top });
gfx_draw_string_left(
dpi, STR_SERVER_GREETING, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_GREETING_INPUT].top });
gfx_draw_string_left(
dpi, STR_PASSWORD, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PASSWORD_INPUT].top });
gfx_draw_string_left(
dpi, STR_MAX_PLAYERS, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_MAXPLAYERS].top });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PORT_INPUT].top }, STR_PORT, {}, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_NAME_INPUT].top }, STR_SERVER_NAME, {}, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_DESCRIPTION_INPUT].top }, STR_SERVER_DESCRIPTION, {},
{ w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_GREETING_INPUT].top }, STR_SERVER_GREETING, {},
{ w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_PASSWORD_INPUT].top }, STR_PASSWORD, {}, { w->colours[1] });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 6, w->widgets[WIDX_MAXPLAYERS].top }, STR_MAX_PLAYERS, {}, { w->colours[1] });
}
#endif

16
src/openrct2-ui/windows/Staff.cpp
View File

@ -1097,13 +1097,13 @@ void window_staff_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
auto ft = Formatter();
ft.Add<money32>(GetStaffWage(peep->AssignedStaffType));
gfx_draw_string_left(dpi, STR_STAFF_STAT_WAGES, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_WAGES, ft);
screenCoords.y += LIST_ROW_HEIGHT;
}
auto ft = Formatter();
ft.Add<int32_t>(peep->GetHireDate());
gfx_draw_string_left(dpi, STR_STAFF_STAT_EMPLOYED_FOR, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_EMPLOYED_FOR, ft);
screenCoords.y += LIST_ROW_HEIGHT;
switch (peep->AssignedStaffType)
@ -1111,32 +1111,32 @@ void window_staff_stats_paint(rct_window* w, rct_drawpixelinfo* dpi)
case StaffType::Handyman:
ft = Formatter();
ft.Add<uint16_t>(peep->StaffLawnsMown);
gfx_draw_string_left(dpi, STR_STAFF_STAT_LAWNS_MOWN, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_LAWNS_MOWN, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint16_t>(peep->StaffGardensWatered);
gfx_draw_string_left(dpi, STR_STAFF_STAT_GARDENS_WATERED, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_GARDENS_WATERED, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint16_t>(peep->StaffLitterSwept);
gfx_draw_string_left(dpi, STR_STAFF_STAT_LITTER_SWEPT, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_LITTER_SWEPT, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint16_t>(peep->StaffBinsEmptied);
gfx_draw_string_left(dpi, STR_STAFF_STAT_BINS_EMPTIED, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_BINS_EMPTIED, ft);
break;
case StaffType::Mechanic:
ft = Formatter();
ft.Add<uint16_t>(peep->StaffRidesInspected);
gfx_draw_string_left(dpi, STR_STAFF_STAT_RIDES_INSPECTED, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_RIDES_INSPECTED, ft);
screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter();
ft.Add<uint16_t>(peep->StaffRidesFixed);
gfx_draw_string_left(dpi, STR_STAFF_STAT_RIDES_FIXED, ft.Data(), COLOUR_BLACK, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_RIDES_FIXED, ft);
break;
case StaffType::Security:
case StaffType::Entertainer:

14
src/openrct2-ui/windows/StaffList.cpp
View File

@ -287,15 +287,14 @@ public:
{
auto ft = Formatter();
ft.Add<money32>(GetStaffWage(GetSelectedStaffType()));
gfx_draw_string_left(
&dpi, STR_COST_PER_MONTH, ft.Data(), COLOUR_BLACK, windowPos + ScreenCoordsXY{ width - 155, 32 });
DrawTextBasic(&dpi, windowPos + ScreenCoordsXY{ width - 155, 32 }, STR_COST_PER_MONTH, ft);
}
if (GetSelectedStaffType() != StaffType::Entertainer)
{
gfx_draw_string_left(
&dpi, STR_UNIFORM_COLOUR, nullptr, COLOUR_BLACK,
windowPos + ScreenCoordsXY{ 6, widgets[WIDX_STAFF_LIST_UNIFORM_COLOUR_PICKER].top + 1 });
DrawTextBasic(
&dpi, windowPos + ScreenCoordsXY{ 6, widgets[WIDX_STAFF_LIST_UNIFORM_COLOUR_PICKER].top + 1 },
STR_UNIFORM_COLOUR);
}
auto namingConvention = GetStaffNamingConvention(GetSelectedStaffType());
@ -305,9 +304,8 @@ public:
ft.Add<uint16_t>(_staffList.size());
ft.Add<rct_string_id>(staffTypeStringId);
gfx_draw_string_left(
&dpi, STR_STAFF_LIST_COUNTER, ft.Data(), COLOUR_BLACK,
windowPos + ScreenCoordsXY{ 4, widgets[WIDX_STAFF_LIST_LIST].bottom + 2 });
DrawTextBasic(
&dpi, windowPos + ScreenCoordsXY{ 4, widgets[WIDX_STAFF_LIST_LIST].bottom + 2 }, STR_STAFF_LIST_COUNTER, ft);
}
ScreenSize OnScrollGetSize(int32_t scrollIndex) override

8
src/openrct2-ui/windows/Themes.cpp
View File

@ -818,9 +818,9 @@ void window_themes_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (_selected_tab == WINDOW_THEMES_TAB_SETTINGS)
{
gfx_draw_string_left(
dpi, STR_THEMES_LABEL_CURRENT_THEME, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_themes_widgets[WIDX_THEMES_PRESETS].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_themes_widgets[WIDX_THEMES_PRESETS].top + 1 },
STR_THEMES_LABEL_CURRENT_THEME, {}, { w->colours[1] });
size_t activeAvailableThemeIndex = ThemeManagerGetAvailableThemeIndex();
const utf8* activeThemeName = ThemeManagerGetAvailableThemeName(activeAvailableThemeIndex);
@ -896,7 +896,7 @@ void window_themes_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi, int32_t sc
int32_t numColours = ThemeDescGetNumColours(wc);
for (uint8_t j = 0; j < numColours; j++)
{
gfx_draw_string_left(dpi, ThemeDescGetName(wc), nullptr, w->colours[1], { 2, screenCoords.y + 4 });
DrawTextBasic(dpi, { 2, screenCoords.y + 4 }, ThemeDescGetName(wc), {}, { w->colours[1] });
uint8_t colour = ThemeGetColour(wc, j);
uint32_t image = SPRITE_ID_PALETTE_COLOUR_1(colour & ~COLOUR_FLAG_TRANSLUCENT) | SPR_PALETTE_BTN;

215
src/openrct2-ui/windows/TileInspector.cpp
View File

@ -1792,7 +1792,7 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
terrainNameId = surfaceStyle->NameStringId;
}
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_TERAIN, &terrainNameId, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SURFACE_TERAIN, &terrainNameId, { COLOUR_WHITE });
// Edge texture name
rct_string_id terrainEdgeNameId = STR_EMPTY;
@ -1801,9 +1801,9 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
terrainEdgeNameId = edgeStyle->NameStringId;
}
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_SURFACE_EDGE, &terrainEdgeNameId, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_SURFACE_EDGE, &terrainEdgeNameId,
{ COLOUR_WHITE });
// Land ownership
rct_string_id landOwnership;
@ -1817,31 +1817,31 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
landOwnership = STR_CONSTRUCTION_RIGHTS_SALE;
else
landOwnership = STR_TILE_INSPECTOR_LAND_NOT_OWNED_AND_NOT_AVAILABLE;
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_SURFACE_OWNERSHIP, &landOwnership, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_SURFACE_OWNERSHIP, &landOwnership,
{ COLOUR_WHITE });
// Water level
uint32_t waterLevel = tileElement->AsSurface()->GetWaterHeight();
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_SURFACE_WATER_LEVEL, &waterLevel, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 33 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_SURFACE_WATER_LEVEL, &waterLevel,
{ COLOUR_WHITE });
// Properties
// Raise / lower label
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7, w->widgets[WIDX_SURFACE_SPINNER_HEIGHT].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_SURFACE_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
// Raised corners
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7, w->widgets[WIDX_SURFACE_CHECK_CORNER_E].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_CORNERS, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SURFACE_CORNERS, {}, { COLOUR_WHITE });
break;
}
@ -1850,7 +1850,7 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Details
// Path name
rct_string_id pathNameId = tileElement->AsPath()->GetSurfaceEntry()->string_idx;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_PATH_NAME, &pathNameId, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_PATH_NAME, &pathNameId, { COLOUR_WHITE });
// Path addition
if (tileElement->AsPath()->HasAddition())
@ -1860,30 +1860,30 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
rct_string_id additionNameId = sceneryElement != nullptr
? sceneryElement->name
: static_cast<rct_string_id>(STR_UNKNOWN_OBJECT_TYPE);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_PATH_ADDITIONS, &additionNameId, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_PATH_ADDITIONS, &additionNameId,
{ COLOUR_WHITE });
}
else
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_PATH_ADDITIONS_NONE, nullptr, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_PATH_ADDITIONS_NONE, {},
{ COLOUR_WHITE });
// Properties
// Raise / lower label
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7, w->widgets[WIDX_PATH_SPINNER_HEIGHT].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_PATH_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
// Path connections
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7, w->widgets[WIDX_PATH_CHECK_EDGE_W].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_PATH_CONNECTED_EDGES, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_PATH_CONNECTED_EDGES, {}, { COLOUR_WHITE });
break;
}
@ -1897,34 +1897,34 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (ride != nullptr)
{
auto rideName = ride->GetRideTypeDescriptor().Naming.Name;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_RIDE_TYPE, &rideName, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_TRACK_RIDE_TYPE, &rideName, { COLOUR_WHITE });
}
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_TRACK_RIDE_ID, &rideId, COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_TRACK_RIDE_ID, &rideId, { COLOUR_WHITE });
if (ride != nullptr)
{
auto ft = Formatter();
ride->FormatNameTo(ft);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_TRACK_RIDE_NAME, ft.Data(), COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_TRACK_RIDE_NAME, ft, { COLOUR_WHITE });
}
// Track
auto trackType = trackElement->GetTrackType();
int16_t sequenceNumber = trackElement->GetSequenceIndex();
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_TRACK_PIECE_ID, &trackType, COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 33 });
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_TRACK_SEQUENCE, &sequenceNumber, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 44 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_TRACK_PIECE_ID, &trackType,
{ COLOUR_WHITE });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 44 }, STR_TILE_INSPECTOR_TRACK_SEQUENCE, &sequenceNumber,
{ COLOUR_WHITE });
if (trackElement->IsStation())
{
int16_t stationIndex = trackElement->GetStationIndex();
auto ft = Formatter();
ft.Add<rct_string_id>(STR_COMMA16);
ft.Add<int16_t>(stationIndex);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_STATION_INDEX, ft.Data(), COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 55 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 55 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { COLOUR_WHITE });
}
else
{
@ -1932,23 +1932,24 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
auto ft = Formatter();
ft.Add<rct_string_id>(STR_STRING);
ft.Add<char*>(stationNone);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_STATION_INDEX, ft.Data(), COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 55 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 55 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { COLOUR_WHITE });
}
rct_string_id colourScheme = ColourSchemeNames[trackElement->GetColourScheme()];
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_COLOUR_SCHEME, &colourScheme, COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 66 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 66 }, STR_TILE_INSPECTOR_COLOUR_SCHEME, &colourScheme,
{ COLOUR_WHITE });
// Properties
// Raise / lower label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_TRACK_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_TRACK_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
break;
}
@ -1957,7 +1958,7 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Details
// Age
int16_t age = tileElement->AsSmallScenery()->GetAge();
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SCENERY_AGE, &age, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SCENERY_AGE, &age, { COLOUR_WHITE });
// Quadrant value
const rct_scenery_entry* sceneryEntry = get_small_scenery_entry(tileElement->AsSmallScenery()->GetEntryIndex());
@ -1968,35 +1969,35 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
STR_TILE_INSPECTOR_SCENERY_QUADRANT_NW,
STR_TILE_INSPECTOR_SCENERY_QUADRANT_NE,
STR_TILE_INSPECTOR_SCENERY_QUADRANT_SE };
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_SCENERY_QUADRANT, &quadrant_string_idx[quadrant], COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_SCENERY_QUADRANT,
&quadrant_string_idx[quadrant], { COLOUR_WHITE });
}
// Scenery ID
int16_t idx = tileElement->AsSmallScenery()->GetEntryIndex();
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_SCENERY_ENTRY_IDX, &idx, COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_SCENERY_ENTRY_IDX, &idx, { COLOUR_WHITE });
// Properties
// Raise / Lower
screenCoords.y = w->windowPos.y + w->widgets[WIDX_SCENERY_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_SCENERY_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
// Quarter tile
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7,
w->widgets[WIDX_SCENERY_CHECK_QUARTER_E].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SCENERY_QUADRANT_LABEL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_SCENERY_QUADRANT_LABEL, {}, { COLOUR_WHITE });
// Collision
screenCoords.y = w->windowPos.y + w->widgets[WIDX_SCENERY_CHECK_COLLISION_E].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_COLLISSION, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_COLLISSION, {}, { COLOUR_WHITE });
break;
}
@ -2005,16 +2006,16 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Details
// Entrance type
rct_string_id entranceType = EntranceTypeStringIds[tileElement->AsEntrance()->GetEntranceType()];
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_TYPE, &entranceType, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_ENTRANCE_TYPE, &entranceType, { COLOUR_WHITE });
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_PARK_ENTRANCE)
{
// TODO: Make this work with Left/Right park entrance parts
int16_t parkEntranceIndex = park_entrance_get_index(
{ windowTileInspectorToolMap, tileElement->GetBaseZ() });
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, &parkEntranceIndex, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID,
&parkEntranceIndex, { COLOUR_WHITE });
}
else
{
@ -2022,16 +2023,16 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (tileElement->AsEntrance()->GetEntranceType() == ENTRANCE_TYPE_RIDE_ENTRANCE)
{
// Ride entrance ID
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, &rideEntranceIndex, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID,
&rideEntranceIndex, { COLOUR_WHITE });
}
else
{
// Ride exit ID
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRANCE_EXIT_ID, &rideEntranceIndex, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRANCE_EXIT_ID,
&rideEntranceIndex, { COLOUR_WHITE });
}
}
@ -2039,36 +2040,36 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
// Entrance part
rct_string_id entrancePart = ParkEntrancePartStringIds[tileElement->AsEntrance()->GetSequenceIndex()];
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRANCE_PART, &entrancePart, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRANCE_PART, &entrancePart,
{ COLOUR_WHITE });
}
else
{
// Ride ID
int16_t rideId = tileElement->AsEntrance()->GetRideIndex();
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRANCE_RIDE_ID, &rideId, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRANCE_RIDE_ID, &rideId,
{ COLOUR_WHITE });
// Station index
int16_t stationIndex = tileElement->AsEntrance()->GetStationIndex();
auto ft = Formatter();
ft.Add<rct_string_id>(STR_COMMA16);
ft.Add<int16_t>(stationIndex);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_STATION_INDEX, ft.Data(), COLOUR_WHITE, screenCoords + ScreenCoordsXY{ 0, 33 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 33 }, STR_TILE_INSPECTOR_STATION_INDEX, ft, { COLOUR_WHITE });
}
// Properties
// Raise / Lower
screenCoords.y = w->windowPos.y + w->widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].left + 3;
auto ft = Formatter();
ft.Add<int32_t>(tileElement->base_height);
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, ft.Data(), COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { COLOUR_WHITE });
break;
}
@ -2077,7 +2078,7 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Details
// Type
int16_t wallType = tileElement->AsWall()->GetEntryIndex();
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_WALL_TYPE, &wallType, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_TYPE, &wallType, { COLOUR_WHITE });
// Banner info
rct_wall_scenery_entry wallEntry = get_wall_entry(wallType)->wall;
@ -2088,46 +2089,46 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
Formatter ft;
banner->FormatTextTo(ft);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft.Data(), COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft,
{ COLOUR_WHITE });
}
}
else
{
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, nullptr, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, {},
{ COLOUR_WHITE });
}
// Properties
// Raise / lower label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_WALL_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_WALL_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
// Slope label
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_GROUPBOX_DETAILS].left + 7, w->widgets[WIDX_WALL_DROPDOWN_SLOPE].top };
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_WALL_SLOPE, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_SLOPE, {}, { COLOUR_WHITE });
// Animation frame label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_WALL_ANIMATION_FRAME, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_WALL_ANIMATION_FRAME, {}, { COLOUR_WHITE });
// Current animation frame
uint8_t colour = COLOUR_WHITE;
colour_t colour = COLOUR_WHITE;
if (WidgetIsDisabled(w, WIDX_WALL_SPINNER_ANIMATION_FRAME))
{
colour = w->colours[0] | COLOUR_FLAG_INSET;
}
screenCoords.x = w->windowPos.x + w->widgets[WIDX_WALL_SPINNER_ANIMATION_FRAME].left + 3;
int32_t animationFrame = tileElement->AsWall()->GetAnimationFrame();
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &animationFrame, colour, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &animationFrame, { colour });
break;
}
@ -2137,13 +2138,13 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Type
auto sceneryElement = tileElement->AsLargeScenery();
int16_t largeSceneryType = sceneryElement->GetEntryIndex();
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_LARGE_SCENERY_TYPE, &largeSceneryType, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_LARGE_SCENERY_TYPE, &largeSceneryType, { COLOUR_WHITE });
// Part ID
int16_t pieceID = sceneryElement->GetSequenceIndex();
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_LARGE_SCENERY_PIECE_ID, &pieceID, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 11 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 11 }, STR_TILE_INSPECTOR_LARGE_SCENERY_PIECE_ID, &pieceID,
{ COLOUR_WHITE });
// Banner info
rct_scenery_entry* largeSceneryEntry = get_large_scenery_entry(largeSceneryType);
@ -2154,27 +2155,27 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
Formatter ft;
banner->FormatTextTo(ft);
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft.Data(), COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft,
{ COLOUR_WHITE });
}
}
else
{
gfx_draw_string_left(
dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, nullptr, COLOUR_WHITE,
screenCoords + ScreenCoordsXY{ 0, 22 });
DrawTextBasic(
dpi, screenCoords + ScreenCoordsXY{ 0, 22 }, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, {},
{ COLOUR_WHITE });
}
// Properties
// Raise / lower label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
break;
}
@ -2187,23 +2188,23 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
Formatter ft;
banner->FormatTextTo(ft);
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft.Data(), COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, ft, { COLOUR_WHITE });
}
// Properties
// Raise / lower label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_BANNER_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_BANNER_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
// Blocked paths
screenCoords.y += 28;
screenCoords.x = w->windowPos.x + w->widgets[WIDX_GROUPBOX_DETAILS].left + 7;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BANNER_BLOCKED_PATHS, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BANNER_BLOCKED_PATHS, {}, { COLOUR_WHITE });
break;
}
@ -2212,12 +2213,12 @@ static void window_tile_inspector_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Properties
// Raise / lower label
screenCoords.y = w->windowPos.y + w->widgets[WIDX_CORRUPT_SPINNER_HEIGHT].top;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, nullptr, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_TILE_INSPECTOR_BASE_HEIGHT_FULL, {}, { COLOUR_WHITE });
// Current base height
screenCoords.x = w->windowPos.x + w->widgets[WIDX_CORRUPT_SPINNER_HEIGHT].left + 3;
int32_t baseHeight = tileElement->base_height;
gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_WHITE, screenCoords);
DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, &baseHeight, { COLOUR_WHITE });
break;
}
@ -2339,13 +2340,13 @@ static void window_tile_inspector_scrollpaint(rct_window* w, rct_drawpixelinfo*
ft = Formatter();
ft.Add<rct_string_id>(STR_FORMAT_INTEGER);
ft.Add<int32_t>(baseHeight);
gfx_draw_string_left(dpi, stringFormat, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ COL_X_BH, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ COL_X_BH, 0 }, stringFormat, ft);
// Clearance height
ft = Formatter();
ft.Add<rct_string_id>(STR_FORMAT_INTEGER);
ft.Add<int32_t>(clearanceHeight);
gfx_draw_string_left(dpi, stringFormat, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ COL_X_CH, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ COL_X_CH, 0 }, stringFormat, ft);
// Checkmarks for ghost and last for tile
ft = Formatter();
@ -2353,11 +2354,11 @@ static void window_tile_inspector_scrollpaint(rct_window* w, rct_drawpixelinfo*
ft.Add<char*>(CheckBoxMarkString);
if (ghost)
{
gfx_draw_string_left(dpi, stringFormat, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ COL_X_GF, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ COL_X_GF, 0 }, stringFormat, ft);
}
if (last)
{
gfx_draw_string_left(dpi, stringFormat, ft.Data(), COLOUR_BLACK, screenCoords + ScreenCoordsXY{ COL_X_LF, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ COL_X_LF, 0 }, stringFormat, ft);
}
screenCoords.y -= SCROLLABLE_ROW_HEIGHT;

6
src/openrct2-ui/windows/TitleCommandEditor.cpp
View File

@ -763,8 +763,8 @@ static void window_title_command_editor_paint(rct_window* w, rct_drawpixelinfo*
TITLE_COMMAND_ORDER command_info = get_command_info(_command.Type);
// "Command:" label
gfx_draw_string_left(
dpi, STR_TITLE_COMMAND_EDITOR_COMMAND_LABEL, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ WS, BY - 14 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ WS, BY - 14 }, STR_TITLE_COMMAND_EDITOR_COMMAND_LABEL, {}, { w->colours[1] });
// Command dropdown name
DrawTextEllipsised(
@ -773,7 +773,7 @@ static void window_title_command_editor_paint(rct_window* w, rct_drawpixelinfo*
w->colours[1]);
// Label (e.g. "Location:")
gfx_draw_string_left(dpi, command_info.descStringId, nullptr, w->colours[1], w->windowPos + ScreenCoordsXY{ WS, BY2 - 14 });
DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ WS, BY2 - 14 }, command_info.descStringId, {}, { w->colours[1] });
if (_command.Type == TitleScript::Speed)
{

10
src/openrct2-ui/windows/TitleEditor.cpp
View File

@ -807,9 +807,9 @@ static void window_title_editor_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
case WINDOW_TITLE_EDITOR_TAB_PRESETS:
{
gfx_draw_string_left(
dpi, STR_TITLE_SEQUENCE, nullptr, w->colours[1],
w->windowPos + ScreenCoordsXY{ 10, window_title_editor_widgets[WIDX_TITLE_EDITOR_PRESETS].top + 1 });
DrawTextBasic(
dpi, w->windowPos + ScreenCoordsXY{ 10, window_title_editor_widgets[WIDX_TITLE_EDITOR_PRESETS].top + 1 },
STR_TITLE_SEQUENCE, {}, { w->colours[1] });
auto ft = Formatter();
ft.Add<const char*>(_sequenceName);
@ -886,7 +886,7 @@ static void window_title_editor_scrollpaint_saves(rct_window* w, rct_drawpixelin
ft.Add<rct_string_id>(STR_STRING);
}
ft.Add<const char*>(saveName);
gfx_draw_string_left(dpi, STR_STRINGID, ft.Data(), w->colours[1], screenCoords + ScreenCoordsXY{ 5, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 5, 0 }, STR_STRINGID, ft, { w->colours[1] });
}
}
@ -1045,7 +1045,7 @@ static void window_title_editor_scrollpaint_commands(rct_window* w, rct_drawpixe
log_warning("Unknown command %d", command.Type);
}
}
gfx_draw_string_left(dpi, STR_STRINGID, ft.Data(), w->colours[1], screenCoords + ScreenCoordsXY{ 5, 0 });
DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 5, 0 }, STR_STRINGID, ft, { w->colours[1] });
}
}

37
src/openrct2-ui/windows/TrackList.cpp
View File

@ -566,15 +566,15 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Stats
fixed32_2dp rating = _loadedTrackDesign->excitement * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_EXCITEMENT_RATING, &rating, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_EXCITEMENT_RATING, &rating);
screenPos.y += LIST_ROW_HEIGHT;
rating = _loadedTrackDesign->intensity * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_INTENSITY_RATING, &rating, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_INTENSITY_RATING, &rating);
screenPos.y += LIST_ROW_HEIGHT;
rating = _loadedTrackDesign->nausea * 10;
gfx_draw_string_left(dpi, STR_TRACK_LIST_NAUSEA_RATING, &rating, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_NAUSEA_RATING, &rating);
screenPos.y += LIST_ROW_HEIGHT + 4;
// Information for tracked rides.
@ -586,19 +586,19 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
// Holes
uint16_t holes = _loadedTrackDesign->holes & 0x1F;
gfx_draw_string_left(dpi, STR_HOLES, &holes, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_HOLES, &holes);
screenPos.y += LIST_ROW_HEIGHT;
}
else
{
// Maximum speed
uint16_t speed = ((_loadedTrackDesign->max_speed << 16) * 9) >> 18;
gfx_draw_string_left(dpi, STR_MAX_SPEED, &speed, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_SPEED, &speed);
screenPos.y += LIST_ROW_HEIGHT;
// Average speed
speed = ((_loadedTrackDesign->average_speed << 16) * 9) >> 18;
gfx_draw_string_left(dpi, STR_AVERAGE_SPEED, &speed, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_AVERAGE_SPEED, &speed);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -614,24 +614,24 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
// Maximum positive vertical Gs
int32_t gForces = _loadedTrackDesign->max_positive_vertical_g * 32;
gfx_draw_string_left(dpi, STR_MAX_POSITIVE_VERTICAL_G, &gForces, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_POSITIVE_VERTICAL_G, &gForces);
screenPos.y += LIST_ROW_HEIGHT;
// Maximum negative vertical Gs
gForces = _loadedTrackDesign->max_negative_vertical_g * 32;
gfx_draw_string_left(dpi, STR_MAX_NEGATIVE_VERTICAL_G, &gForces, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_NEGATIVE_VERTICAL_G, &gForces);
screenPos.y += LIST_ROW_HEIGHT;
// Maximum lateral Gs
gForces = _loadedTrackDesign->max_lateral_g * 32;
gfx_draw_string_left(dpi, STR_MAX_LATERAL_G, &gForces, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, &gForces);
screenPos.y += LIST_ROW_HEIGHT;
if (_loadedTrackDesign->total_air_time != 0)
{
// Total air time
int32_t airTime = _loadedTrackDesign->total_air_time * 25;
gfx_draw_string_left(dpi, STR_TOTAL_AIR_TIME, &airTime, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, &airTime);
screenPos.y += LIST_ROW_HEIGHT;
}
}
@ -640,12 +640,12 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
// Drops
uint16_t drops = _loadedTrackDesign->drops & 0x3F;
gfx_draw_string_left(dpi, STR_DROPS, &drops, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_DROPS, &drops);
screenPos.y += LIST_ROW_HEIGHT;
// Drop height is multiplied by 0.75
uint16_t highestDropHeight = (_loadedTrackDesign->highest_drop_height * 3) / 4;
gfx_draw_string_left(dpi, STR_HIGHEST_DROP_HEIGHT, &highestDropHeight, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_HIGHEST_DROP_HEIGHT, &highestDropHeight);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -655,7 +655,7 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
if (inversions != 0)
{
// Inversions
gfx_draw_string_left(dpi, STR_INVERSIONS, &inversions, COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_INVERSIONS, &inversions);
screenPos.y += LIST_ROW_HEIGHT;
}
}
@ -668,7 +668,7 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
ft = Formatter();
ft.Add<uint16_t>(_loadedTrackDesign->space_required_x);
ft.Add<uint16_t>(_loadedTrackDesign->space_required_y);
gfx_draw_string_left(dpi, STR_TRACK_LIST_SPACE_REQUIRED, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += LIST_ROW_HEIGHT;
}
@ -676,7 +676,7 @@ static void window_track_list_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
ft = Formatter();
ft.Add<uint32_t>(_loadedTrackDesign->cost);
gfx_draw_string_left(dpi, STR_TRACK_LIST_COST_AROUND, ft.Data(), COLOUR_BLACK, screenPos);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_COST_AROUND, ft);
}
}
@ -696,8 +696,7 @@ static void window_track_list_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi,
if (_trackDesigns.empty())
{
// No track designs
gfx_draw_string_left(
dpi, STR_NO_TRACK_DESIGNS_OF_THIS_TYPE, nullptr, COLOUR_BLACK, screenCoords - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenCoords - ScreenCoordsXY{ 0, 1 }, STR_NO_TRACK_DESIGNS_OF_THIS_TYPE);
return;
}
}
@ -719,7 +718,7 @@ static void window_track_list_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi,
}
rct_string_id stringId2 = STR_BUILD_CUSTOM_DESIGN;
gfx_draw_string_left(dpi, stringId, &stringId2, COLOUR_BLACK, screenCoords - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenCoords - ScreenCoordsXY{ 0, 1 }, stringId, &stringId2);
screenCoords.y += SCROLLABLE_ROW_HEIGHT;
listIndex++;
}
@ -746,7 +745,7 @@ static void window_track_list_scrollpaint(rct_window* w, rct_drawpixelinfo* dpi,
auto ft = Formatter();
ft.Add<rct_string_id>(STR_TRACK_LIST_NAME_FORMAT);
ft.Add<utf8*>(_trackDesigns[i].name);
gfx_draw_string_left(dpi, stringId, ft.Data(), COLOUR_BLACK, screenCoords - ScreenCoordsXY{ 0, 1 });
DrawTextBasic(dpi, screenCoords - ScreenCoordsXY{ 0, 1 }, stringId, ft);
}
screenCoords.y += SCROLLABLE_ROW_HEIGHT;

18
src/openrct2-ui/windows/ViewClipping.cpp
View File

@ -381,7 +381,7 @@ static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi)
// Clip height value
auto screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CLIP_HEIGHT_VALUE].top };
gfx_draw_string_left(dpi, STR_VIEW_CLIPPING_HEIGHT_VALUE, nullptr, w->colours[0], screenCoords);
DrawTextBasic(dpi, screenCoords, STR_VIEW_CLIPPING_HEIGHT_VALUE, {}, { w->colours[0] });
screenCoords = w->windowPos
+ ScreenCoordsXY{ w->widgets[WIDX_CLIP_HEIGHT_VALUE].left + 1, w->widgets[WIDX_CLIP_HEIGHT_VALUE].top };
@ -394,8 +394,8 @@ static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
case DISPLAY_TYPE::DISPLAY_RAW:
default:
gfx_draw_string_left(
dpi, STR_FORMAT_INTEGER, &clipHeightRawValue, w->colours[0], screenCoords); // Printing the raw value.
DrawTextBasic(
dpi, screenCoords, STR_FORMAT_INTEGER, &clipHeightRawValue, { w->colours[0] }); // Printing the raw value.
break;
case DISPLAY_TYPE::DISPLAY_UNITS:
@ -404,9 +404,9 @@ static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi)
{
// Height label is Units.
clipHeightValueInUnits = static_cast<fixed16_1dp>(FIXED_1DP(gClipHeight, 0) / 2 - FIXED_1DP(7, 0));
gfx_draw_string_left(
dpi, STR_UNIT1DP_NO_SUFFIX, &clipHeightValueInUnits, w->colours[0],
screenCoords); // Printing the value in Height Units.
DrawTextBasic(
dpi, screenCoords, STR_UNIT1DP_NO_SUFFIX, &clipHeightValueInUnits,
{ w->colours[0] }); // Printing the value in Height Units.
}
else
{
@ -418,13 +418,13 @@ static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi)
case MeasurementFormat::SI:
clipHeightValueInMeters = static_cast<fixed32_2dp>(
FIXED_2DP(gClipHeight, 0) / 2 * 1.5f - FIXED_2DP(10, 50));
gfx_draw_string_left(
dpi, STR_UNIT2DP_SUFFIX_METRES, &clipHeightValueInMeters, w->colours[0], screenCoords);
DrawTextBasic(
dpi, screenCoords, STR_UNIT2DP_SUFFIX_METRES, &clipHeightValueInMeters, { w->colours[0] });
break;
case MeasurementFormat::Imperial:
clipHeightValueInFeet = static_cast<fixed16_1dp>(
FIXED_1DP(gClipHeight, 0) / 2.0f * 5 - FIXED_1DP(35, 0));
gfx_draw_string_left(dpi, STR_UNIT1DP_SUFFIX_FEET, &clipHeightValueInFeet, w->colours[0], screenCoords);
DrawTextBasic(dpi, screenCoords, STR_UNIT1DP_SUFFIX_FEET, &clipHeightValueInFeet, { w->colours[0] });
break;
}
}

4
src/openrct2/drawing/Drawing.h
View File

@ -739,10 +739,6 @@ void gfx_draw_string(rct_drawpixelinfo* dpi, const_utf8string buffer, uint8_t co
void gfx_draw_string_no_formatting(
rct_drawpixelinfo* dpi, const_utf8string buffer, uint8_t colour, const ScreenCoordsXY& coords);
/** @deprecated */
void gfx_draw_string_left(
rct_drawpixelinfo* dpi, rct_string_id format, void* args, uint8_t colour, const ScreenCoordsXY& coords);
int32_t gfx_draw_string_left_wrapped(
rct_drawpixelinfo* dpi, void* args, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, uint8_t colour);
int32_t gfx_draw_string_centred_wrapped(

7
src/openrct2/drawing/Text.cpp
View File

@ -156,13 +156,6 @@ void gfx_draw_string_no_formatting(
DrawText(dpi, coords, textPaint, buffer, true);
}
// Basic
void gfx_draw_string_left(
rct_drawpixelinfo* dpi, rct_string_id format, void* args, uint8_t colour, const ScreenCoordsXY& coords)
{
DrawTextBasic(dpi, coords, format, args, { colour, TextAlignment::LEFT });
}
// Wrapping
int32_t gfx_draw_string_left_wrapped(
rct_drawpixelinfo* dpi, void* args, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, uint8_t colour)

6
src/openrct2/drawing/Text.h
View File

@ -11,6 +11,7 @@
#include "../common.h"
#include "../interface/Colour.h"
#include "../localisation/Formatter.h"
#include "Font.h"
struct ScreenCoordsXY;
@ -144,9 +145,10 @@ public:
};
void DrawTextBasic(
rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const Formatter& ft, TextPaint textPaint);
rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const Formatter& ft = {},
TextPaint textPaint = {});
void DrawTextBasic(
rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const void* args, TextPaint textPaint);
rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const void* args, TextPaint textPaint = {});
void DrawTextEllipsised(
rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, const Formatter& ft,
colour_t colour, TextAlignment alignment = TextAlignment::LEFT, bool underline = false);