mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

Codechange: Use parameterised GetString() for drawing NewGRF info. (#13674)

pull/13675/head
Peter Nelson 2025-02-28 21:05:12 +00:00 committed by GitHub
parent 09716dba75
commit 57f0ed716e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 70 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/newgrf_badge.cpp
View File

@ -461,9 +461,7 @@ int DrawBadgeNameList(Rect r, std::span<const BadgeID> badges, GrfSpecFeature)
if (s.empty()) continue; if (s.empty()) continue;
SetDParam(0, class_badge->name); r.top = DrawStringMultiLine(r, GetString(STR_BADGE_NAME_LIST, class_badge->name, std::move(s)), TC_BLACK);
SetDParamStr(1, std::move(s));
r.top = DrawStringMultiLine(r, STR_BADGE_NAME_LIST, TC_BLACK);
} }
return r.top; return r.top;

37
src/newgrf_debug_gui.cpp
View File

@ -455,6 +455,15 @@ struct NewGRFInspectWindow : Window {
} }
} }
std::string GetPropertyString(const NIProperty &nip, uint value) const
{
switch (nip.type) {
case NIT_INT: return GetString(STR_JUST_INT, value);
case NIT_CARGO: return GetString(IsValidCargoType(value) ? CargoSpec::Get(value)->name : STR_QUANTITY_N_A);
default: NOT_REACHED();
}
}
/** /**
* Helper function to draw the main panel widget. * Helper function to draw the main panel widget.
* @param r The rectangle to draw within. * @param r The rectangle to draw within.
@ -519,22 +528,7 @@ struct NewGRFInspectWindow : Window {
default: NOT_REACHED(); default: NOT_REACHED();
} }
StringID string; this->DrawString(r, i++, fmt::format(" {:02x}: {} ({})", nip.prop, this->GetPropertyString(nip, value), nip.name));
SetDParam(0, value);
switch (nip.type) {
case NIT_INT:
string = STR_JUST_INT;
break;
case NIT_CARGO:
string = IsValidCargoType(value) ? CargoSpec::Get(value)->name : STR_QUANTITY_N_A;
break;
default:
NOT_REACHED();
}
this->DrawString(r, i++, fmt::format(" {:02x}: {} ({})", nip.prop, GetString(string), nip.name));
} }
} }
@ -941,9 +935,7 @@ struct SpriteAlignerWindow : Window {
case WID_SA_LIST: { case WID_SA_LIST: {
Dimension d = {}; Dimension d = {};
for (const auto &spritefile : GetCachedSpriteFiles()) { for (const auto &spritefile : GetCachedSpriteFiles()) {
SetDParamStr(0, spritefile->GetSimplifiedFilename()); d = maxdim(d, GetStringBoundingBox(GetString(STR_SPRITE_ALIGNER_SPRITE, spritefile->GetSimplifiedFilename(), GetParamMaxDigits(6))));
SetDParamMaxDigits(1, 6);
d = maxdim(d, GetStringBoundingBox(STR_SPRITE_ALIGNER_SPRITE));
} }
size.width = d.width + padding.width; size.width = d.width + padding.width;
resize.height = GetCharacterHeight(FS_NORMAL) + padding.height; resize.height = GetCharacterHeight(FS_NORMAL) + padding.height;
@ -1005,12 +997,9 @@ struct SpriteAlignerWindow : Window {
for (auto it = first; it != last; ++it) { for (auto it = first; it != last; ++it) {
const SpriteFile *file = GetOriginFile(*it); const SpriteFile *file = GetOriginFile(*it);
if (file == nullptr) { if (file == nullptr) {
SetDParam(0, *it); DrawString(ir, GetString(STR_JUST_COMMA, *it), *it == this->current_sprite ? TC_WHITE : (TC_GREY | TC_NO_SHADE), SA_RIGHT | SA_FORCE);
DrawString(ir, STR_JUST_COMMA, *it == this->current_sprite ? TC_WHITE : (TC_GREY | TC_NO_SHADE), SA_RIGHT | SA_FORCE);
} else { } else {
SetDParamStr(0, file->GetSimplifiedFilename()); DrawString(ir, GetString(STR_SPRITE_ALIGNER_SPRITE, file->GetSimplifiedFilename(), GetSpriteLocalID(*it)), *it == this->current_sprite ? TC_WHITE : TC_BLACK);
SetDParam(1, GetSpriteLocalID(*it));
DrawString(ir, STR_SPRITE_ALIGNER_SPRITE, *it == this->current_sprite ? TC_WHITE : TC_BLACK);
} }
ir.top += step_size; ir.top += step_size;
} }

124
src/newgrf_gui.cpp
View File

@ -68,61 +68,56 @@ void ShowNewGRFError()
} }
} }
static StringID GetGRFPaletteString(uint8_t palette)
{
if (palette & GRFP_BLT_32BPP) {
return (palette & GRFP_USE_WINDOWS) ? STR_NEWGRF_SETTINGS_PALETTE_LEGACY_32BPP : STR_NEWGRF_SETTINGS_PALETTE_DEFAULT_32BPP;
}
return (palette & GRFP_USE_WINDOWS) ? STR_NEWGRF_SETTINGS_PALETTE_LEGACY : STR_NEWGRF_SETTINGS_PALETTE_DEFAULT;
}
static void ShowNewGRFInfo(const GRFConfig &c, const Rect &r, bool show_params) static void ShowNewGRFInfo(const GRFConfig &c, const Rect &r, bool show_params)
{ {
Rect tr = r.Shrink(WidgetDimensions::scaled.frametext); Rect tr = r.Shrink(WidgetDimensions::scaled.frametext);
if (c.error.has_value()) { if (c.error.has_value()) {
SetDParamStr(0, c.error->custom_message); // is skipped by built-in messages std::array<StringParameter, 3 + std::tuple_size_v<decltype(c.error->param_value)>> params{};
SetDParamStr(1, c.filename); auto it = params.begin();
SetDParamStr(2, c.error->data); *it++ = c.error->custom_message; // is skipped by built-in messages
for (uint i = 0; i < c.error->param_value.size(); i++) { *it++ = c.filename;
SetDParam(3 + i, c.error->param_value[i]); *it++ = c.error->data;
} for (const uint32_t &value : c.error->param_value) *it++ = value;
SetDParamStr(0, GetString(c.error->message != STR_NULL ? c.error->message : STR_JUST_RAW_STRING)); tr.top = DrawStringMultiLine(tr, GetString(c.error->severity, GetStringWithArgs(c.error->message != STR_NULL ? c.error->message : STR_JUST_RAW_STRING, {params.begin(), it})));
tr.top = DrawStringMultiLine(tr, c.error->severity);
} }
/* Draw filename or not if it is not known (GRF sent over internet) */ /* Draw filename or not if it is not known (GRF sent over internet) */
if (!c.filename.empty()) { if (!c.filename.empty()) {
SetDParamStr(0, c.filename); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_FILENAME, c.filename));
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_FILENAME);
} }
/* Prepare and draw GRF ID */ /* Prepare and draw GRF ID */
SetDParamStr(0, fmt::format("{:08X}", std::byteswap(c.ident.grfid))); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_GRF_ID, fmt::format("{:08X}", std::byteswap(c.ident.grfid))));
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_GRF_ID);
if ((_settings_client.gui.newgrf_developer_tools || _settings_client.gui.newgrf_show_old_versions) && c.version != 0) { if ((_settings_client.gui.newgrf_developer_tools || _settings_client.gui.newgrf_show_old_versions) && c.version != 0) {
SetDParam(0, c.version); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_VERSION, c.version));
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_VERSION);
} }
if ((_settings_client.gui.newgrf_developer_tools || _settings_client.gui.newgrf_show_old_versions) && c.min_loadable_version != 0) { if ((_settings_client.gui.newgrf_developer_tools || _settings_client.gui.newgrf_show_old_versions) && c.min_loadable_version != 0) {
SetDParam(0, c.min_loadable_version); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_MIN_VERSION, c.min_loadable_version));
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_MIN_VERSION);
} }
/* Prepare and draw MD5 sum */ /* Prepare and draw MD5 sum */
SetDParamStr(0, FormatArrayAsHex(c.ident.md5sum)); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_MD5SUM, FormatArrayAsHex(c.ident.md5sum)));
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_MD5SUM);
/* Show GRF parameter list */ /* Show GRF parameter list */
if (show_params) { if (show_params) {
if (!c.param.empty()) { if (!c.param.empty()) {
SetDParam(0, STR_JUST_RAW_STRING); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_PARAMETER, STR_JUST_RAW_STRING, GRFBuildParamList(c)));
SetDParamStr(1, GRFBuildParamList(c));
} else { } else {
SetDParam(0, STR_NEWGRF_SETTINGS_PARAMETER_NONE); tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_PARAMETER, STR_NEWGRF_SETTINGS_PARAMETER_NONE));
} }
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_PARAMETER);
/* Draw the palette of the NewGRF */ /* Draw the palette of the NewGRF */
if (c.palette & GRFP_BLT_32BPP) { tr.top = DrawStringMultiLine(tr, GetString(STR_NEWGRF_SETTINGS_PALETTE, GetGRFPaletteString(c.palette)));
SetDParam(0, (c.palette & GRFP_USE_WINDOWS) ? STR_NEWGRF_SETTINGS_PALETTE_LEGACY_32BPP : STR_NEWGRF_SETTINGS_PALETTE_DEFAULT_32BPP);
} else {
SetDParam(0, (c.palette & GRFP_USE_WINDOWS) ? STR_NEWGRF_SETTINGS_PALETTE_LEGACY : STR_NEWGRF_SETTINGS_PALETTE_DEFAULT);
}
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_PALETTE);
} }
/* Show flags */ /* Show flags */
@ -133,8 +128,7 @@ static void ShowNewGRFInfo(const GRFConfig &c, const Rect &r, bool show_params)
/* Draw GRF info if it exists */ /* Draw GRF info if it exists */
if (!StrEmpty(c.GetDescription())) { if (!StrEmpty(c.GetDescription())) {
SetDParamStr(0, c.GetDescription()); tr.top = DrawStringMultiLine(tr, GetString(STR_JUST_RAW_STRING, c.GetDescription()), TC_BLACK);
tr.top = DrawStringMultiLine(tr, STR_JUST_RAW_STRING, TC_BLACK);
} else { } else {
tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_NO_INFO); tr.top = DrawStringMultiLine(tr, STR_NEWGRF_SETTINGS_NO_INFO);
} }
@ -217,8 +211,7 @@ struct NewGRFParametersWindow : public Window {
} }
case WID_NP_NUMPAR: { case WID_NP_NUMPAR: {
SetDParamMaxValue(0, GRFConfig::MAX_NUM_PARAMS); Dimension d = GetStringBoundingBox(GetString(this->GetWidget<NWidgetCore>(widget)->GetString(), GetParamMaxValue(GRFConfig::MAX_NUM_PARAMS)));
Dimension d = GetStringBoundingBox(this->GetWidget<NWidgetCore>(widget)->GetString());
d.width += padding.width; d.width += padding.width;
d.height += padding.height; d.height += padding.height;
size = maxdim(size, d); size = maxdim(size, d);
@ -258,6 +251,27 @@ struct NewGRFParametersWindow : public Window {
} }
} }
std::pair<StringParameter, StringParameter> GetValueParams(const GRFParameterInfo &par_info, uint32_t value) const
{
if (par_info.type == PTYPE_BOOL) return {value != 0 ? STR_CONFIG_SETTING_ON : STR_CONFIG_SETTING_OFF, {}};
auto it = std::ranges::lower_bound(par_info.value_names, value, std::less{}, &GRFParameterInfo::ValueName::first);
if (it != std::end(par_info.value_names) && it->first == value) {
if (const char *label = GetGRFStringFromGRFText(it->second); label != nullptr) return {STR_JUST_RAW_STRING, label};
}
return {STR_JUST_INT, value};
}
std::string GetSettingString(const GRFParameterInfo &par_info, int i, uint32_t value) const
{
auto [param1, param2] = this->GetValueParams(par_info, value);
const char *name = GetGRFStringFromGRFText(par_info.name);
return name == nullptr
? GetString(STR_NEWGRF_PARAMETERS_SETTING, STR_NEWGRF_PARAMETERS_DEFAULT_NAME, i + 1, param1, param2)
: GetString(STR_NEWGRF_PARAMETERS_SETTING, STR_JUST_RAW_STRING, name, param1, param2);
}
void DrawWidget(const Rect &r, WidgetID widget) const override void DrawWidget(const Rect &r, WidgetID widget) const override
{ {
if (widget == WID_NP_DESCRIPTION) { if (widget == WID_NP_DESCRIPTION) {
@ -285,35 +299,15 @@ struct NewGRFParametersWindow : public Window {
if (par_info.type == PTYPE_BOOL) { if (par_info.type == PTYPE_BOOL) {
DrawBoolButton(buttons_left, ir.top + button_y_offset, current_value != 0, this->editable); DrawBoolButton(buttons_left, ir.top + button_y_offset, current_value != 0, this->editable);
SetDParam(2, this->grf_config.GetValue(par_info) == 0 ? STR_CONFIG_SETTING_OFF : STR_CONFIG_SETTING_ON);
} else if (par_info.type == PTYPE_UINT_ENUM) { } else if (par_info.type == PTYPE_UINT_ENUM) {
if (par_info.complete_labels) { if (par_info.complete_labels) {
DrawDropDownButton(buttons_left, ir.top + button_y_offset, COLOUR_YELLOW, this->clicked_row == i && this->clicked_dropdown, this->editable); DrawDropDownButton(buttons_left, ir.top + button_y_offset, COLOUR_YELLOW, this->clicked_row == i && this->clicked_dropdown, this->editable);
} else { } else {
DrawArrowButtons(buttons_left, ir.top + button_y_offset, COLOUR_YELLOW, (this->clicked_button == i) ? 1 + (this->clicked_increase != rtl) : 0, this->editable && current_value > par_info.min_value, this->editable && current_value < par_info.max_value); DrawArrowButtons(buttons_left, ir.top + button_y_offset, COLOUR_YELLOW, (this->clicked_button == i) ? 1 + (this->clicked_increase != rtl) : 0, this->editable && current_value > par_info.min_value, this->editable && current_value < par_info.max_value);
} }
SetDParam(2, STR_JUST_INT);
SetDParam(3, current_value);
auto it = std::ranges::lower_bound(par_info.value_names, current_value, std::less{}, &GRFParameterInfo::ValueName::first);
if (it != std::end(par_info.value_names) && it->first == current_value) {
const char *label = GetGRFStringFromGRFText(it->second);
if (label != nullptr) {
SetDParam(2, STR_JUST_RAW_STRING);
SetDParamStr(3, label);
}
}
} }
const char *name = GetGRFStringFromGRFText(par_info.name); DrawString(tr.left, tr.right, ir.top + text_y_offset, this->GetSettingString(par_info, i, current_value), selected ? TC_WHITE : TC_LIGHT_BLUE);
if (name != nullptr) {
SetDParam(0, STR_JUST_RAW_STRING);
SetDParamStr(1, name);
} else {
SetDParam(0, STR_NEWGRF_PARAMETERS_DEFAULT_NAME);
SetDParam(1, i + 1);
}
DrawString(tr.left, tr.right, ir.top + text_y_offset, STR_NEWGRF_PARAMETERS_SETTING, selected ? TC_WHITE : TC_LIGHT_BLUE);
ir.top += this->line_height; ir.top += this->line_height;
} }
} }
@ -760,8 +754,7 @@ struct NewGRFWindow : public Window, NewGRFScanCallback {
case WID_NS_PRESET_LIST: { case WID_NS_PRESET_LIST: {
Dimension d = GetStringBoundingBox(STR_NUM_CUSTOM); Dimension d = GetStringBoundingBox(STR_NUM_CUSTOM);
for (const auto &i : this->grf_presets) { for (const auto &i : this->grf_presets) {
SetDParamStr(0, i); d = maxdim(d, GetStringBoundingBox(GetString(STR_JUST_RAW_STRING, i)));
d = maxdim(d, GetStringBoundingBox(STR_JUST_RAW_STRING));
} }
d.width += padding.width; d.width += padding.width;
size = maxdim(d, size); size = maxdim(d, size);
@ -2168,23 +2161,21 @@ struct ScanProgressWindow : public Window {
void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
{ {
switch (widget) { switch (widget) {
case WID_SP_PROGRESS_BAR: { case WID_SP_PROGRESS_BAR:
SetDParamMaxValue(0, 100); size = GetStringBoundingBox(GetString(STR_GENERATION_PROGRESS, GetParamMaxValue(100)));
size = GetStringBoundingBox(STR_GENERATION_PROGRESS);
/* We need some spacing for the 'border' */ /* We need some spacing for the 'border' */
size.height += WidgetDimensions::scaled.frametext.Horizontal(); size.height += WidgetDimensions::scaled.frametext.Horizontal();
size.width += WidgetDimensions::scaled.frametext.Vertical(); size.width += WidgetDimensions::scaled.frametext.Vertical();
break; break;
}
case WID_SP_PROGRESS_TEXT: case WID_SP_PROGRESS_TEXT: {
SetDParamMaxDigits(0, 4); uint64_t max_digits = GetParamMaxDigits(4);
SetDParamMaxDigits(1, 4);
/* We really don't know the width. We could determine it by scanning the NewGRFs, /* We really don't know the width. We could determine it by scanning the NewGRFs,
* but this is the status window for scanning them... */ * but this is the status window for scanning them... */
size.width = std::max<uint>(size.width, GetStringBoundingBox(STR_NEWGRF_SCAN_STATUS).width + padding.width); size.width = std::max<uint>(size.width, GetStringBoundingBox(GetString(STR_NEWGRF_SCAN_STATUS, max_digits, max_digits)).width + padding.width);
size.height = GetCharacterHeight(FS_NORMAL) * 2 + WidgetDimensions::scaled.vsep_normal; size.height = GetCharacterHeight(FS_NORMAL) * 2 + WidgetDimensions::scaled.vsep_normal;
break; break;
}
} }
} }
@ -2197,15 +2188,12 @@ struct ScanProgressWindow : public Window {
Rect ir = r.Shrink(WidgetDimensions::scaled.bevel); Rect ir = r.Shrink(WidgetDimensions::scaled.bevel);
uint percent = scanned * 100 / std::max(1U, _settings_client.gui.last_newgrf_count); uint percent = scanned * 100 / std::max(1U, _settings_client.gui.last_newgrf_count);
DrawFrameRect(ir.WithWidth(ir.Width() * percent / 100, _current_text_dir == TD_RTL), COLOUR_MAUVE, {}); DrawFrameRect(ir.WithWidth(ir.Width() * percent / 100, _current_text_dir == TD_RTL), COLOUR_MAUVE, {});
SetDParam(0, percent); DrawString(ir.left, ir.right, CenterBounds(ir.top, ir.bottom, GetCharacterHeight(FS_NORMAL)), GetString(STR_GENERATION_PROGRESS, percent), TC_FROMSTRING, SA_HOR_CENTER);
DrawString(ir.left, ir.right, CenterBounds(ir.top, ir.bottom, GetCharacterHeight(FS_NORMAL)), STR_GENERATION_PROGRESS, TC_FROMSTRING, SA_HOR_CENTER);
break; break;
} }
case WID_SP_PROGRESS_TEXT: case WID_SP_PROGRESS_TEXT:
SetDParam(0, this->scanned); DrawString(r.left, r.right, r.top, GetString(STR_NEWGRF_SCAN_STATUS, this->scanned, _settings_client.gui.last_newgrf_count), TC_FROMSTRING, SA_HOR_CENTER);
SetDParam(1, _settings_client.gui.last_newgrf_count);
DrawString(r.left, r.right, r.top, STR_NEWGRF_SCAN_STATUS, TC_FROMSTRING, SA_HOR_CENTER);
DrawString(r.left, r.right, r.top + GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.vsep_normal, this->last_name, TC_BLACK, SA_HOR_CENTER); DrawString(r.left, r.right, r.top + GetCharacterHeight(FS_NORMAL) + WidgetDimensions::scaled.vsep_normal, this->last_name, TC_BLACK, SA_HOR_CENTER);
break; break;