Archives
/
OpenTTD-patches
mirror of https://github.com/JGRennison/OpenTTD-patches
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(svn r13042) -Codechange: make a class of CreateScenarioWindow, GenerateLandscapeWindow, NetworkChatWindow, NetworkCompanyPasswordWindow, NetworkGameWindow, NetworkStartServerWindow, QueryStringWindow, SaveLoadWindow. All these classes depended on the 'querystr_d' object which is now put into QueryStringBaseWindow. As a side effect this removes quite a lot of WP macro usages and a few global variables.

Browse Source
pull/155/head
rubidium 16 years ago
parent 29ad1d442a
commit d8a6bb392a
7 changed files with 1876 additions and 1805 deletions
Show Stats Download Patch File Download Diff File

803
src/genworld_gui.cpp
Unescape Escape View File

@ -29,6 +29,7 @@
#include "widgets/dropdown_func.h" #include "widgets/dropdown_func.h"
#include "core/random_func.hpp" #include "core/random_func.hpp"
#include "landscape_type.h" #include "landscape_type.h"
#include "querystring_gui.h"
#include "table/strings.h" #include "table/strings.h"
#include "table/sprites.h" #include "table/sprites.h"
@ -43,14 +44,6 @@ enum glwp_modes {
GLWP_END GLWP_END
}; };
struct generate_d {
uint widget_id;
uint x;
uint y;
char name[64];
};
assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(generate_d));
extern void SwitchMode(int new_mode); extern void SwitchMode(int new_mode);
static inline void SetNewLandscapeType(byte landscape) static inline void SetNewLandscapeType(byte landscape)
@ -244,314 +237,324 @@ static DropDownList *BuildMapsizeDropDown()
return list; return list;
} }
static void GenerateLandscapeWndProc(Window *w, WindowEvent *e) static const StringID _elevations[] = {STR_682A_VERY_FLAT, STR_682B_FLAT, STR_682C_HILLY, STR_682D_MOUNTAINOUS, INVALID_STRING_ID};
{ static const StringID _sea_lakes[] = {STR_VERY_LOW, STR_6820_LOW, STR_6821_MEDIUM, STR_6822_HIGH, INVALID_STRING_ID};
static const StringID elevations[] = {STR_682A_VERY_FLAT, STR_682B_FLAT, STR_682C_HILLY, STR_682D_MOUNTAINOUS, INVALID_STRING_ID}; static const StringID _smoothness[] = {STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_VERY_SMOOTH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_SMOOTH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_ROUGH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_VERY_ROUGH, INVALID_STRING_ID};
static const StringID sea_lakes[] = {STR_VERY_LOW, STR_6820_LOW, STR_6821_MEDIUM, STR_6822_HIGH, INVALID_STRING_ID}; static const StringID _tree_placer[] = {STR_CONFIG_PATCHES_TREE_PLACER_NONE, STR_CONFIG_PATCHES_TREE_PLACER_ORIGINAL, STR_CONFIG_PATCHES_TREE_PLACER_IMPROVED, INVALID_STRING_ID};
static const StringID smoothness[] = {STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_VERY_SMOOTH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_SMOOTH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_ROUGH, STR_CONFIG_PATCHES_ROUGHNESS_OF_TERRAIN_VERY_ROUGH, INVALID_STRING_ID}; static const StringID _rotation[] = {STR_CONFIG_PATCHES_HEIGHTMAP_ROTATION_COUNTER_CLOCKWISE, STR_CONFIG_PATCHES_HEIGHTMAP_ROTATION_CLOCKWISE, INVALID_STRING_ID};
static const StringID tree_placer[] = {STR_CONFIG_PATCHES_TREE_PLACER_NONE, STR_CONFIG_PATCHES_TREE_PLACER_ORIGINAL, STR_CONFIG_PATCHES_TREE_PLACER_IMPROVED, INVALID_STRING_ID}; static const StringID _landscape[] = {STR_CONFIG_PATCHES_LAND_GENERATOR_ORIGINAL, STR_CONFIG_PATCHES_LAND_GENERATOR_TERRA_GENESIS, INVALID_STRING_ID};
static const StringID rotation[] = {STR_CONFIG_PATCHES_HEIGHTMAP_ROTATION_COUNTER_CLOCKWISE, STR_CONFIG_PATCHES_HEIGHTMAP_ROTATION_CLOCKWISE, INVALID_STRING_ID}; static const StringID _num_towns[] = {STR_NUM_VERY_LOW, STR_6816_LOW, STR_6817_NORMAL, STR_6818_HIGH, INVALID_STRING_ID};
static const StringID landscape[] = {STR_CONFIG_PATCHES_LAND_GENERATOR_ORIGINAL, STR_CONFIG_PATCHES_LAND_GENERATOR_TERRA_GENESIS, INVALID_STRING_ID}; static const StringID _num_inds[] = {STR_NONE, STR_NUM_VERY_LOW, STR_6816_LOW, STR_6817_NORMAL, STR_6818_HIGH, INVALID_STRING_ID};
static const StringID num_towns[] = {STR_NUM_VERY_LOW, STR_6816_LOW, STR_6817_NORMAL, STR_6818_HIGH, INVALID_STRING_ID};
static const StringID num_inds[] = {STR_NONE, STR_NUM_VERY_LOW, STR_6816_LOW, STR_6817_NORMAL, STR_6818_HIGH, INVALID_STRING_ID};
/* Data used for the generate seed edit box */ struct GenerateLandscapeWindow : public QueryStringBaseWindow {
static querystr_d _genseed_query; uint widget_id;
static char _genseed_buffer[11]; uint x;
uint y;
char name[64];
glwp_modes mode;
glwp_modes mode = (glwp_modes)w->window_number; GenerateLandscapeWindow(const WindowDesc *desc, void *data = NULL, WindowNumber number = 0) : QueryStringBaseWindow(desc, NULL, number)
{
this->LowerWidget(_opt_newgame.landscape + GLAND_TEMPERATE);
switch (e->event) { snprintf(this->edit_str_buf, sizeof(this->edit_str_buf), "%u", _patches_newgame.generation_seed);
case WE_CREATE: InitializeTextBuffer(&this->text, this->edit_str_buf, lengthof(this->edit_str_buf), 120);
w->LowerWidget(_opt_newgame.landscape + GLAND_TEMPERATE); this->caption = STR_NULL;
this->afilter = CS_NUMERAL;
snprintf(_genseed_buffer, sizeof(_genseed_buffer), "%u", _patches_newgame.generation_seed); this->mode = (glwp_modes)this->window_number;
InitializeTextBuffer(&_genseed_query.text, _genseed_buffer, lengthof(_genseed_buffer), 120);
_genseed_query.caption = STR_NULL;
_genseed_query.afilter = CS_NUMERAL;
break;
case WE_PAINT: this->FindWindowPlacementAndResize(desc);
/* You can't select smoothness if not terragenesis */ }
if (mode == GLWP_GENERATE) {
w->SetWidgetDisabledState(GLAND_SMOOTHNESS_PULLDOWN, _patches_newgame.land_generator == 0);
}
/* Disable snowline if not hilly */
w->SetWidgetDisabledState(GLAND_SNOW_LEVEL_TEXT, _opt_newgame.landscape != LT_ARCTIC);
/* Disable town, industry and trees in SE */
w->SetWidgetDisabledState(GLAND_TOWN_PULLDOWN, _game_mode == GM_EDITOR);
w->SetWidgetDisabledState(GLAND_INDUSTRY_PULLDOWN, _game_mode == GM_EDITOR);
w->SetWidgetDisabledState(GLAND_TREE_PULLDOWN, _game_mode == GM_EDITOR);
w->SetWidgetDisabledState(GLAND_START_DATE_DOWN, _patches_newgame.starting_year <= MIN_YEAR);
w->SetWidgetDisabledState(GLAND_START_DATE_UP, _patches_newgame.starting_year >= MAX_YEAR);
w->SetWidgetDisabledState(GLAND_SNOW_LEVEL_DOWN, _patches_newgame.snow_line_height <= 2 || _opt_newgame.landscape != LT_ARCTIC);
w->SetWidgetDisabledState(GLAND_SNOW_LEVEL_UP, _patches_newgame.snow_line_height >= MAX_SNOWLINE_HEIGHT || _opt_newgame.landscape != LT_ARCTIC);
w->SetWidgetLoweredState(GLAND_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
w->SetWidgetLoweredState(GLAND_ARCTIC, _opt_newgame.landscape == LT_ARCTIC);
w->SetWidgetLoweredState(GLAND_TROPICAL, _opt_newgame.landscape == LT_TROPIC);
w->SetWidgetLoweredState(GLAND_TOYLAND, _opt_newgame.landscape == LT_TOYLAND);
if (_game_mode == GM_EDITOR) {
w->widget[GLAND_TOWN_PULLDOWN].data = STR_6836_OFF;
w->widget[GLAND_INDUSTRY_PULLDOWN].data = STR_6836_OFF;
} else {
w->widget[GLAND_TOWN_PULLDOWN].data = num_towns[_opt_newgame.diff.number_towns];
w->widget[GLAND_INDUSTRY_PULLDOWN].data = num_inds[_opt_newgame.diff.number_industries];
}
if (mode == GLWP_GENERATE) { virtual void OnPaint()
w->widget[GLAND_LANDSCAPE_PULLDOWN].data = landscape[_patches_newgame.land_generator]; {
w->widget[GLAND_TREE_PULLDOWN].data = tree_placer[_patches_newgame.tree_placer]; /* You can't select smoothness if not terragenesis */
w->widget[GLAND_TERRAIN_PULLDOWN].data = elevations[_opt_newgame.diff.terrain_type]; if (mode == GLWP_GENERATE) {
w->widget[GLAND_WATER_PULLDOWN].data = sea_lakes[_opt_newgame.diff.quantity_sea_lakes]; this->SetWidgetDisabledState(GLAND_SMOOTHNESS_PULLDOWN, _patches_newgame.land_generator == 0);
w->widget[GLAND_SMOOTHNESS_PULLDOWN].data = smoothness[_patches_newgame.tgen_smoothness]; }
/* Disable snowline if not hilly */
this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_TEXT, _opt_newgame.landscape != LT_ARCTIC);
/* Disable town, industry and trees in SE */
this->SetWidgetDisabledState(GLAND_TOWN_PULLDOWN, _game_mode == GM_EDITOR);
this->SetWidgetDisabledState(GLAND_INDUSTRY_PULLDOWN, _game_mode == GM_EDITOR);
this->SetWidgetDisabledState(GLAND_TREE_PULLDOWN, _game_mode == GM_EDITOR);
this->SetWidgetDisabledState(GLAND_START_DATE_DOWN, _patches_newgame.starting_year <= MIN_YEAR);
this->SetWidgetDisabledState(GLAND_START_DATE_UP, _patches_newgame.starting_year >= MAX_YEAR);
this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_DOWN, _patches_newgame.snow_line_height <= 2 || _opt_newgame.landscape != LT_ARCTIC);
this->SetWidgetDisabledState(GLAND_SNOW_LEVEL_UP, _patches_newgame.snow_line_height >= MAX_SNOWLINE_HEIGHT || _opt_newgame.landscape != LT_ARCTIC);
this->SetWidgetLoweredState(GLAND_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
this->SetWidgetLoweredState(GLAND_ARCTIC, _opt_newgame.landscape == LT_ARCTIC);
this->SetWidgetLoweredState(GLAND_TROPICAL, _opt_newgame.landscape == LT_TROPIC);
this->SetWidgetLoweredState(GLAND_TOYLAND, _opt_newgame.landscape == LT_TOYLAND);
if (_game_mode == GM_EDITOR) {
this->widget[GLAND_TOWN_PULLDOWN].data = STR_6836_OFF;
this->widget[GLAND_INDUSTRY_PULLDOWN].data = STR_6836_OFF;
} else {
this->widget[GLAND_TOWN_PULLDOWN].data = _num_towns[_opt_newgame.diff.number_towns];
this->widget[GLAND_INDUSTRY_PULLDOWN].data = _num_inds[_opt_newgame.diff.number_industries];
}
if (mode == GLWP_GENERATE) {
this->widget[GLAND_LANDSCAPE_PULLDOWN].data = _landscape[_patches_newgame.land_generator];
this->widget[GLAND_TREE_PULLDOWN].data = _tree_placer[_patches_newgame.tree_placer];
this->widget[GLAND_TERRAIN_PULLDOWN].data = _elevations[_opt_newgame.diff.terrain_type];
this->widget[GLAND_WATER_PULLDOWN].data = _sea_lakes[_opt_newgame.diff.quantity_sea_lakes];
this->widget[GLAND_SMOOTHNESS_PULLDOWN].data = _smoothness[_patches_newgame.tgen_smoothness];
} else {
this->widget[GLAND_TREE_PULLDOWN].data = _tree_placer[_patches_newgame.tree_placer];
this->widget[GLAND_HEIGHTMAP_ROTATION_PULLDOWN].data = _rotation[_patches_newgame.heightmap_rotation];
}
/* Set parameters for widget text that requires them. */
SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // GLAND_START_DATE_TEXT
SetDParam(1, 1 << _patches_newgame.map_x); // GLAND_MAPSIZE_X_PULLDOWN
SetDParam(2, 1 << _patches_newgame.map_y); // GLAND_MAPSIZE_Y_PULLDOWN
SetDParam(3, _patches_newgame.snow_line_height); // GLAND_SNOW_LEVEL_TEXT
DrawWindowWidgets(this);
this->DrawEditBox(GLAND_RANDOM_EDITBOX);
if (mode != GLWP_GENERATE) {
char buffer[512];
if (_patches_newgame.heightmap_rotation == HM_CLOCKWISE) {
SetDParam(0, this->y);
SetDParam(1, this->x);
} else { } else {
w->widget[GLAND_TREE_PULLDOWN].data = tree_placer[_patches_newgame.tree_placer]; SetDParam(0, this->x);
w->widget[GLAND_HEIGHTMAP_ROTATION_PULLDOWN].data = rotation[_patches_newgame.heightmap_rotation]; SetDParam(1, this->y);
} }
GetString(buffer, STR_HEIGHTMAP_SIZE, lastof(buffer));
DrawStringRightAligned(326, 91, STR_HEIGHTMAP_SIZE, TC_BLACK);
/* Set parameters for widget text that requires them. */ DrawString( 12, 91, STR_HEIGHTMAP_NAME, TC_BLACK);
SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // GLAND_START_DATE_TEXT SetDParamStr(0, this->name);
SetDParam(1, 1 << _patches_newgame.map_x); // GLAND_MAPSIZE_X_PULLDOWN DrawStringTruncated(114, 91, STR_ORANGE, TC_BLACK, 326 - 114 - GetStringBoundingBox(buffer).width - 5);
SetDParam(2, 1 << _patches_newgame.map_y); // GLAND_MAPSIZE_Y_PULLDOWN }
SetDParam(3, _patches_newgame.snow_line_height); // GLAND_SNOW_LEVEL_TEXT }
DrawWindowWidgets(w);
DrawEditBox(w, &_genseed_query, GLAND_RANDOM_EDITBOX);
if (mode != GLWP_GENERATE) {
char buffer[512];
if (_patches_newgame.heightmap_rotation == HM_CLOCKWISE) { virtual void OnClick(Point pt, int widget)
SetDParam(0, WP(w, generate_d).y); {
SetDParam(1, WP(w, generate_d).x); switch (widget) {
case 0: delete this; break;
case GLAND_TEMPERATE:
case GLAND_ARCTIC:
case GLAND_TROPICAL:
case GLAND_TOYLAND:
this->RaiseWidget(_opt_newgame.landscape + GLAND_TEMPERATE);
SetNewLandscapeType(widget - GLAND_TEMPERATE);
break;
case GLAND_MAPSIZE_X_PULLDOWN: // Mapsize X
ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_x, GLAND_MAPSIZE_X_PULLDOWN);
break;
case GLAND_MAPSIZE_Y_PULLDOWN: // Mapsize Y
ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_y, GLAND_MAPSIZE_Y_PULLDOWN);
break;
case GLAND_TOWN_PULLDOWN: // Number of towns
ShowDropDownMenu(this, _num_towns, _opt_newgame.diff.number_towns, GLAND_TOWN_PULLDOWN, 0, 0);
break;
case GLAND_INDUSTRY_PULLDOWN: // Number of industries
ShowDropDownMenu(this, _num_inds, _opt_newgame.diff.number_industries, GLAND_INDUSTRY_PULLDOWN, 0, 0);
break;
case GLAND_RANDOM_BUTTON: // Random seed
_patches_newgame.generation_seed = InteractiveRandom();
snprintf(this->edit_str_buf, lengthof(this->edit_str_buf), "%u", _patches_newgame.generation_seed);
UpdateTextBufferSize(&this->text);
this->SetDirty();
break;
case GLAND_RANDOM_EDITBOX: // edit box for random seed
ShowOnScreenKeyboard(this, GLAND_RANDOM_EDITBOX, 0, 0);
break;
case GLAND_GENERATE_BUTTON: // Generate
UpdatePatches();
if (_patches.town_layout == TL_NO_ROADS) {
ShowQuery(
STR_TOWN_LAYOUT_WARNING_CAPTION,
STR_TOWN_LAYOUT_WARNING_MESSAGE,
this,
LandscapeGenerationCallback);
} else if (mode == GLWP_HEIGHTMAP &&
(this->x * 2 < (1U << _patches_newgame.map_x) ||
this->x / 2 > (1U << _patches_newgame.map_x) ||
this->y * 2 < (1U << _patches_newgame.map_y) ||
this->y / 2 > (1U << _patches_newgame.map_y))) {
ShowQuery(
STR_HEIGHTMAP_SCALE_WARNING_CAPTION,
STR_HEIGHTMAP_SCALE_WARNING_MESSAGE,
this,
LandscapeGenerationCallback);
} else { } else {
SetDParam(0, WP(w, generate_d).x); StartGeneratingLandscape(mode);
SetDParam(1, WP(w, generate_d).y);
} }
GetString(buffer, STR_HEIGHTMAP_SIZE, lastof(buffer)); break;
DrawStringRightAligned(326, 91, STR_HEIGHTMAP_SIZE, TC_BLACK);
DrawString( 12, 91, STR_HEIGHTMAP_NAME, TC_BLACK);
SetDParamStr(0, WP(w, generate_d).name);
DrawStringTruncated(114, 91, STR_ORANGE, TC_BLACK, 326 - 114 - GetStringBoundingBox(buffer).width - 5);
}
break;
case WE_CLICK:
switch (e->we.click.widget) {
case 0: delete w; break;
case GLAND_TEMPERATE:
case GLAND_ARCTIC:
case GLAND_TROPICAL:
case GLAND_TOYLAND:
w->RaiseWidget(_opt_newgame.landscape + GLAND_TEMPERATE);
SetNewLandscapeType(e->we.click.widget - GLAND_TEMPERATE);
break;
case GLAND_MAPSIZE_X_PULLDOWN: // Mapsize X
ShowDropDownList(w, BuildMapsizeDropDown(), _patches_newgame.map_x, GLAND_MAPSIZE_X_PULLDOWN);
break;
case GLAND_MAPSIZE_Y_PULLDOWN: // Mapsize Y
ShowDropDownList(w, BuildMapsizeDropDown(), _patches_newgame.map_y, GLAND_MAPSIZE_Y_PULLDOWN);
break;
case GLAND_TOWN_PULLDOWN: // Number of towns
ShowDropDownMenu(w, num_towns, _opt_newgame.diff.number_towns, GLAND_TOWN_PULLDOWN, 0, 0);
break;
case GLAND_INDUSTRY_PULLDOWN: // Number of industries
ShowDropDownMenu(w, num_inds, _opt_newgame.diff.number_industries, GLAND_INDUSTRY_PULLDOWN, 0, 0);
break;
case GLAND_RANDOM_BUTTON: // Random seed
_patches_newgame.generation_seed = InteractiveRandom();
snprintf(_genseed_buffer, lengthof(_genseed_buffer), "%u", _patches_newgame.generation_seed);
UpdateTextBufferSize(&_genseed_query.text);
w->SetDirty();
break;
case GLAND_RANDOM_EDITBOX: // edit box for random seed case GLAND_START_DATE_DOWN:
ShowOnScreenKeyboard(w, & _genseed_query, GLAND_RANDOM_EDITBOX, 0, 0); case GLAND_START_DATE_UP: // Year buttons
break; /* Don't allow too fast scrolling */
if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
case GLAND_GENERATE_BUTTON: // Generate this->HandleButtonClick(widget);
UpdatePatches(); this->SetDirty();
if (_patches.town_layout == TL_NO_ROADS) {
ShowQuery(
STR_TOWN_LAYOUT_WARNING_CAPTION,
STR_TOWN_LAYOUT_WARNING_MESSAGE,
w,
LandscapeGenerationCallback);
} else if (mode == GLWP_HEIGHTMAP &&
(WP(w, generate_d).x * 2 < (1U << _patches_newgame.map_x) ||
WP(w, generate_d).x / 2 > (1U << _patches_newgame.map_x) ||
WP(w, generate_d).y * 2 < (1U << _patches_newgame.map_y) ||
WP(w, generate_d).y / 2 > (1U << _patches_newgame.map_y))) {
ShowQuery(
STR_HEIGHTMAP_SCALE_WARNING_CAPTION,
STR_HEIGHTMAP_SCALE_WARNING_MESSAGE,
w,
LandscapeGenerationCallback);
} else {
StartGeneratingLandscape(mode);
}
break;
case GLAND_START_DATE_DOWN:
case GLAND_START_DATE_UP: // Year buttons
/* Don't allow too fast scrolling */
if ((w->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
w->HandleButtonClick(e->we.click.widget);
w->SetDirty();
_patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + e->we.click.widget - GLAND_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
}
_left_button_clicked = false;
break;
case GLAND_START_DATE_TEXT: // Year text
WP(w, generate_d).widget_id = GLAND_START_DATE_TEXT;
SetDParam(0, _patches_newgame.starting_year);
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, w, CS_NUMERAL);
break;
case GLAND_SNOW_LEVEL_DOWN: _patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + widget - GLAND_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
case GLAND_SNOW_LEVEL_UP: // Snow line buttons }
/* Don't allow too fast scrolling */ _left_button_clicked = false;
if ((w->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) { break;
w->HandleButtonClick(e->we.click.widget);
w->SetDirty(); case GLAND_START_DATE_TEXT: // Year text
this->widget_id = GLAND_START_DATE_TEXT;
_patches_newgame.snow_line_height = Clamp(_patches_newgame.snow_line_height + e->we.click.widget - GLAND_SNOW_LEVEL_TEXT, 2, MAX_SNOWLINE_HEIGHT); SetDParam(0, _patches_newgame.starting_year);
} ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
_left_button_clicked = false; break;
break;
case GLAND_SNOW_LEVEL_DOWN:
case GLAND_SNOW_LEVEL_TEXT: // Snow line text case GLAND_SNOW_LEVEL_UP: // Snow line buttons
WP(w, generate_d).widget_id = GLAND_SNOW_LEVEL_TEXT; /* Don't allow too fast scrolling */
SetDParam(0, _patches_newgame.snow_line_height); if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_SNOW_LINE_QUERY_CAPT, 3, 100, w, CS_NUMERAL); this->HandleButtonClick(widget);
break; this->SetDirty();
case GLAND_TREE_PULLDOWN: // Tree placer _patches_newgame.snow_line_height = Clamp(_patches_newgame.snow_line_height + widget - GLAND_SNOW_LEVEL_TEXT, 2, MAX_SNOWLINE_HEIGHT);
ShowDropDownMenu(w, tree_placer, _patches_newgame.tree_placer, GLAND_TREE_PULLDOWN, 0, 0); }
break; _left_button_clicked = false;
break;
case GLAND_LANDSCAPE_PULLDOWN: // Landscape generator OR Heightmap rotation
/* case GLAND_HEIGHTMAP_ROTATION_TEXT: case GLAND_HEIGHTMAP_ROTATION_PULLDOWN:*/ case GLAND_SNOW_LEVEL_TEXT: // Snow line text
if (mode == GLWP_HEIGHTMAP) { this->widget_id = GLAND_SNOW_LEVEL_TEXT;
ShowDropDownMenu(w, rotation, _patches_newgame.heightmap_rotation, GLAND_HEIGHTMAP_ROTATION_PULLDOWN, 0, 0); SetDParam(0, _patches_newgame.snow_line_height);
} else { ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_SNOW_LINE_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
ShowDropDownMenu(w, landscape, _patches_newgame.land_generator, GLAND_LANDSCAPE_PULLDOWN, 0, 0); break;
}
break; case GLAND_TREE_PULLDOWN: // Tree placer
ShowDropDownMenu(this, _tree_placer, _patches_newgame.tree_placer, GLAND_TREE_PULLDOWN, 0, 0);
break;
case GLAND_LANDSCAPE_PULLDOWN: // Landscape generator OR Heightmap rotation
/* case GLAND_HEIGHTMAP_ROTATION_TEXT: case GLAND_HEIGHTMAP_ROTATION_PULLDOWN:*/
if (mode == GLWP_HEIGHTMAP) {
ShowDropDownMenu(this, _rotation, _patches_newgame.heightmap_rotation, GLAND_HEIGHTMAP_ROTATION_PULLDOWN, 0, 0);
} else {
ShowDropDownMenu(this, _landscape, _patches_newgame.land_generator, GLAND_LANDSCAPE_PULLDOWN, 0, 0);
}
break;
case GLAND_TERRAIN_PULLDOWN: // Terrain type case GLAND_TERRAIN_PULLDOWN: // Terrain type
ShowDropDownMenu(w, elevations, _opt_newgame.diff.terrain_type, GLAND_TERRAIN_PULLDOWN, 0, 0); ShowDropDownMenu(this, _elevations, _opt_newgame.diff.terrain_type, GLAND_TERRAIN_PULLDOWN, 0, 0);
break; break;
case GLAND_WATER_PULLDOWN: // Water quantity case GLAND_WATER_PULLDOWN: // Water quantity
ShowDropDownMenu(w, sea_lakes, _opt_newgame.diff.quantity_sea_lakes, GLAND_WATER_PULLDOWN, 0, 0); ShowDropDownMenu(this, _sea_lakes, _opt_newgame.diff.quantity_sea_lakes, GLAND_WATER_PULLDOWN, 0, 0);
break; break;
case GLAND_SMOOTHNESS_PULLDOWN: // Map smoothness case GLAND_SMOOTHNESS_PULLDOWN: // Map smoothness
ShowDropDownMenu(w, smoothness, _patches_newgame.tgen_smoothness, GLAND_SMOOTHNESS_PULLDOWN, 0, 0); ShowDropDownMenu(this, _smoothness, _patches_newgame.tgen_smoothness, GLAND_SMOOTHNESS_PULLDOWN, 0, 0);
break; break;
} }
break; }
case WE_MOUSELOOP:
HandleEditBox(w, &_genseed_query, GLAND_RANDOM_EDITBOX);
break;
case WE_KEYPRESS: virtual void OnMouseLoop()
HandleEditBoxKey(w, &_genseed_query, GLAND_RANDOM_EDITBOX, e); {
/* the seed is unsigned, therefore atoi cannot be used. this->HandleEditBox(GLAND_RANDOM_EDITBOX);
* As 2^32 - 1 (MAX_UVALUE(uint32)) is a 'magic' value }
* (use random seed) it should not be possible to be
* entered into the input field; the generate seed
* button can be used instead. */
_patches_newgame.generation_seed = minu(strtoul(_genseed_buffer, NULL, sizeof(_genseed_buffer) - 1), MAX_UVALUE(uint32) - 1);
break;
case WE_DROPDOWN_SELECT: virtual bool OnKeyPress(uint16 key, uint16 keycode)
switch (e->we.dropdown.button) { {
case GLAND_MAPSIZE_X_PULLDOWN: _patches_newgame.map_x = e->we.dropdown.index; break; bool cont;
case GLAND_MAPSIZE_Y_PULLDOWN: _patches_newgame.map_y = e->we.dropdown.index; break; this->HandleEditBoxKey(GLAND_RANDOM_EDITBOX, key, keycode, cont);
case GLAND_TREE_PULLDOWN: _patches_newgame.tree_placer = e->we.dropdown.index; break; /* the seed is unsigned, therefore atoi cannot be used.
case GLAND_SMOOTHNESS_PULLDOWN: _patches_newgame.tgen_smoothness = e->we.dropdown.index; break; * As 2^32 - 1 (MAX_UVALUE(uint32)) is a 'magic' value
* (use random seed) it should not be possible to be
case GLAND_TOWN_PULLDOWN: * entered into the input field; the generate seed
_opt_newgame.diff.number_towns = e->we.dropdown.index; * button can be used instead. */
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0); _patches_newgame.generation_seed = minu(strtoul(this->edit_str_buf, NULL, sizeof(this->edit_str_buf) - 1), MAX_UVALUE(uint32) - 1);
DoCommandP(0, 2, _opt_newgame.diff.number_towns, NULL, CMD_CHANGE_DIFFICULTY_LEVEL); return cont;
break; }
case GLAND_INDUSTRY_PULLDOWN: virtual void OnDropdownSelect(int widget, int index)
_opt_newgame.diff.number_industries = e->we.dropdown.index; {
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0); switch (widget) {
DoCommandP(0, 3, _opt_newgame.diff.number_industries, NULL, CMD_CHANGE_DIFFICULTY_LEVEL); case GLAND_MAPSIZE_X_PULLDOWN: _patches_newgame.map_x = index; break;
break; case GLAND_MAPSIZE_Y_PULLDOWN: _patches_newgame.map_y = index; break;
case GLAND_TREE_PULLDOWN: _patches_newgame.tree_placer = index; break;
case GLAND_SMOOTHNESS_PULLDOWN: _patches_newgame.tgen_smoothness = index; break;
case GLAND_TOWN_PULLDOWN:
_opt_newgame.diff.number_towns = index;
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
DoCommandP(0, 2, _opt_newgame.diff.number_towns, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
break;
case GLAND_INDUSTRY_PULLDOWN:
_opt_newgame.diff.number_industries = index;
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
DoCommandP(0, 3, _opt_newgame.diff.number_industries, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
break;
case GLAND_LANDSCAPE_PULLDOWN:
/* case GLAND_HEIGHTMAP_PULLDOWN: */
if (mode == GLWP_HEIGHTMAP) {
_patches_newgame.heightmap_rotation = index;
} else {
_patches_newgame.land_generator = index;
}
break;
case GLAND_TERRAIN_PULLDOWN:
_opt_newgame.diff.terrain_type = index;
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
DoCommandP(0, 12, _opt_newgame.diff.terrain_type, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
break;
case GLAND_WATER_PULLDOWN:
_opt_newgame.diff.quantity_sea_lakes = index;
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0);
DoCommandP(0, 13, _opt_newgame.diff.quantity_sea_lakes, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
break;
}
this->SetDirty();
}
case GLAND_LANDSCAPE_PULLDOWN: virtual void OnQueryTextFinished(char *str)
/* case GLAND_HEIGHTMAP_PULLDOWN: */ {
if (mode == GLWP_HEIGHTMAP) { if (!StrEmpty(str)) {
_patches_newgame.heightmap_rotation = e->we.dropdown.index; int32 value = atoi(str);
} else {
_patches_newgame.land_generator = e->we.dropdown.index;
}
break;
case GLAND_TERRAIN_PULLDOWN: switch (this->widget_id) {
_opt_newgame.diff.terrain_type = e->we.dropdown.index; case GLAND_START_DATE_TEXT:
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0); this->InvalidateWidget(GLAND_START_DATE_TEXT);
DoCommandP(0, 12, _opt_newgame.diff.terrain_type, NULL, CMD_CHANGE_DIFFICULTY_LEVEL); _patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
break; break;
case GLAND_WATER_PULLDOWN: case GLAND_SNOW_LEVEL_TEXT:
_opt_newgame.diff.quantity_sea_lakes = e->we.dropdown.index; this->InvalidateWidget(GLAND_SNOW_LEVEL_TEXT);
if (_opt_newgame.diff_level != 3) ShowErrorMessage(INVALID_STRING_ID, STR_DIFFICULTY_TO_CUSTOM, 0, 0); _patches_newgame.snow_line_height = Clamp(value, 2, MAX_SNOWLINE_HEIGHT);
DoCommandP(0, 13, _opt_newgame.diff.quantity_sea_lakes, NULL, CMD_CHANGE_DIFFICULTY_LEVEL);
break; break;
} }
w->SetDirty();
break;
case WE_ON_EDIT_TEXT:
if (!StrEmpty(e->we.edittext.str)) {
int32 value = atoi(e->we.edittext.str);
switch (WP(w, generate_d).widget_id) {
case GLAND_START_DATE_TEXT:
w->InvalidateWidget(GLAND_START_DATE_TEXT);
_patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
break;
case GLAND_SNOW_LEVEL_TEXT: this->SetDirty();
w->InvalidateWidget(GLAND_SNOW_LEVEL_TEXT); }
_patches_newgame.snow_line_height = Clamp(value, 2, MAX_SNOWLINE_HEIGHT);
break;
}
w->SetDirty();
}
break;
} }
} };
static const WindowDesc _generate_landscape_desc = { static const WindowDesc _generate_landscape_desc = {
WDP_CENTER, WDP_CENTER, 338, 268, 338, 268, WDP_CENTER, WDP_CENTER, 338, 268, 338, 268,
WC_GENERATE_LANDSCAPE, WC_NONE, WC_GENERATE_LANDSCAPE, WC_NONE,
WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS, WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,
_generate_landscape_widgets, _generate_landscape_widgets,
GenerateLandscapeWndProc, NULL,
}; };
static const WindowDesc _heightmap_load_desc = { static const WindowDesc _heightmap_load_desc = {
@ -559,7 +562,7 @@ static const WindowDesc _heightmap_load_desc = {
WC_GENERATE_LANDSCAPE, WC_NONE, WC_GENERATE_LANDSCAPE, WC_NONE,
WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS, WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS,
_heightmap_load_widgets, _heightmap_load_widgets,
GenerateLandscapeWndProc, NULL,
}; };
static void _ShowGenerateLandscape(glwp_modes mode) static void _ShowGenerateLandscape(glwp_modes mode)
@ -577,14 +580,12 @@ static void _ShowGenerateLandscape(glwp_modes mode)
if (!GetHeightmapDimensions(_file_to_saveload.name, &x, &y)) return; if (!GetHeightmapDimensions(_file_to_saveload.name, &x, &y)) return;
} }
Window *w = AllocateWindowDescFront<Window>((mode == GLWP_HEIGHTMAP) ? &_heightmap_load_desc : &_generate_landscape_desc, mode); GenerateLandscapeWindow *w = AllocateWindowDescFront<GenerateLandscapeWindow>((mode == GLWP_HEIGHTMAP) ? &_heightmap_load_desc : &_generate_landscape_desc, mode);
if (w == NULL) return;
if (mode == GLWP_HEIGHTMAP) { if (mode == GLWP_HEIGHTMAP) {
WP(w, generate_d).x = x; w->x = x;
WP(w, generate_d).y = y; w->y = y;
strecpy(WP(w, generate_d).name, _file_to_saveload.title, lastof(WP(w, generate_d).name)); strecpy(w->name, _file_to_saveload.title, lastof(w->name));
} }
InvalidateWindow(WC_GENERATE_LANDSCAPE, mode); InvalidateWindow(WC_GENERATE_LANDSCAPE, mode);
@ -639,127 +640,131 @@ enum CreateScenarioWindowWidgets {
}; };
static void CreateScenarioWndProc(Window *w, WindowEvent *e) struct CreateScenarioWindow : public Window
{ {
switch (e->event) { uint widget_id;
case WE_CREATE:
w->LowerWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
break;
case WE_PAINT:
w->SetWidgetDisabledState(CSCEN_START_DATE_DOWN, _patches_newgame.starting_year <= MIN_YEAR);
w->SetWidgetDisabledState(CSCEN_START_DATE_UP, _patches_newgame.starting_year >= MAX_YEAR);
w->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_DOWN, _patches_newgame.se_flat_world_height <= 0);
w->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_UP, _patches_newgame.se_flat_world_height >= MAX_TILE_HEIGHT);
w->SetWidgetLoweredState(CSCEN_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
w->SetWidgetLoweredState(CSCEN_ARCTIC, _opt_newgame.landscape == LT_ARCTIC);
w->SetWidgetLoweredState(CSCEN_TROPICAL, _opt_newgame.landscape == LT_TROPIC);
w->SetWidgetLoweredState(CSCEN_TOYLAND, _opt_newgame.landscape == LT_TOYLAND);
/* Set parameters for widget text that requires them */
SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // CSCEN_START_DATE_TEXT
SetDParam(1, 1 << _patches_newgame.map_x); // CSCEN_MAPSIZE_X_PULLDOWN
SetDParam(2, 1 << _patches_newgame.map_y); // CSCEN_MAPSIZE_Y_PULLDOWN
SetDParam(3, _patches_newgame.se_flat_world_height); // CSCEN_FLAT_LAND_HEIGHT_TEXT
DrawWindowWidgets(w);
break;
case WE_CLICK:
switch (e->we.click.widget) {
case CSCEN_TEMPERATE:
case CSCEN_ARCTIC:
case CSCEN_TROPICAL:
case CSCEN_TOYLAND:
w->RaiseWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
SetNewLandscapeType(e->we.click.widget - CSCEN_TEMPERATE);
break;
case CSCEN_MAPSIZE_X_PULLDOWN: // Mapsize X
ShowDropDownList(w, BuildMapsizeDropDown(), _patches_newgame.map_x, CSCEN_MAPSIZE_X_PULLDOWN);
break;
case CSCEN_MAPSIZE_Y_PULLDOWN: // Mapsize Y
ShowDropDownList(w, BuildMapsizeDropDown(), _patches_newgame.map_y, CSCEN_MAPSIZE_Y_PULLDOWN);
break;
case CSCEN_EMPTY_WORLD: // Empty world / flat world
StartGeneratingLandscape(GLWP_SCENARIO);
break;
case CSCEN_RANDOM_WORLD: // Generate CreateScenarioWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, NULL, window_number)
ShowGenerateLandscape(); {
break; this->LowerWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
}
case CSCEN_START_DATE_DOWN: virtual void OnPaint()
case CSCEN_START_DATE_UP: // Year buttons {
/* Don't allow too fast scrolling */ this->SetWidgetDisabledState(CSCEN_START_DATE_DOWN, _patches_newgame.starting_year <= MIN_YEAR);
if ((w->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) { this->SetWidgetDisabledState(CSCEN_START_DATE_UP, _patches_newgame.starting_year >= MAX_YEAR);
w->HandleButtonClick(e->we.click.widget); this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_DOWN, _patches_newgame.se_flat_world_height <= 0);
w->SetDirty(); this->SetWidgetDisabledState(CSCEN_FLAT_LAND_HEIGHT_UP, _patches_newgame.se_flat_world_height >= MAX_TILE_HEIGHT);
this->SetWidgetLoweredState(CSCEN_TEMPERATE, _opt_newgame.landscape == LT_TEMPERATE);
this->SetWidgetLoweredState(CSCEN_ARCTIC, _opt_newgame.landscape == LT_ARCTIC);
this->SetWidgetLoweredState(CSCEN_TROPICAL, _opt_newgame.landscape == LT_TROPIC);
this->SetWidgetLoweredState(CSCEN_TOYLAND, _opt_newgame.landscape == LT_TOYLAND);
/* Set parameters for widget text that requires them */
SetDParam(0, ConvertYMDToDate(_patches_newgame.starting_year, 0, 1)); // CSCEN_START_DATE_TEXT
SetDParam(1, 1 << _patches_newgame.map_x); // CSCEN_MAPSIZE_X_PULLDOWN
SetDParam(2, 1 << _patches_newgame.map_y); // CSCEN_MAPSIZE_Y_PULLDOWN
SetDParam(3, _patches_newgame.se_flat_world_height); // CSCEN_FLAT_LAND_HEIGHT_TEXT
DrawWindowWidgets(this);
}
_patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + e->we.click.widget - CSCEN_START_DATE_TEXT, MIN_YEAR, MAX_YEAR); virtual void OnClick(Point pt, int widget)
} {
_left_button_clicked = false; switch (widget) {
break; case CSCEN_TEMPERATE:
case CSCEN_ARCTIC:
case CSCEN_TROPICAL:
case CSCEN_TOYLAND:
this->RaiseWidget(_opt_newgame.landscape + CSCEN_TEMPERATE);
SetNewLandscapeType(widget - CSCEN_TEMPERATE);
break;
case CSCEN_MAPSIZE_X_PULLDOWN: // Mapsize X
ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_x, CSCEN_MAPSIZE_X_PULLDOWN);
break;
case CSCEN_MAPSIZE_Y_PULLDOWN: // Mapsize Y
ShowDropDownList(this, BuildMapsizeDropDown(), _patches_newgame.map_y, CSCEN_MAPSIZE_Y_PULLDOWN);
break;
case CSCEN_EMPTY_WORLD: // Empty world / flat world
StartGeneratingLandscape(GLWP_SCENARIO);
break;
case CSCEN_RANDOM_WORLD: // Generate
ShowGenerateLandscape();
break;
case CSCEN_START_DATE_DOWN:
case CSCEN_START_DATE_UP: // Year buttons
/* Don't allow too fast scrolling */
if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
this->HandleButtonClick(widget);
this->SetDirty();
_patches_newgame.starting_year = Clamp(_patches_newgame.starting_year + widget - CSCEN_START_DATE_TEXT, MIN_YEAR, MAX_YEAR);
}
_left_button_clicked = false;
break;
case CSCEN_START_DATE_TEXT: // Year text
this->widget_id = CSCEN_START_DATE_TEXT;
SetDParam(0, _patches_newgame.starting_year);
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, this, CS_NUMERAL);
break;
case CSCEN_FLAT_LAND_HEIGHT_DOWN:
case CSCEN_FLAT_LAND_HEIGHT_UP: // Height level buttons
/* Don't allow too fast scrolling */
if ((this->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) {
this->HandleButtonClick(widget);
this->SetDirty();
_patches_newgame.se_flat_world_height = Clamp(_patches_newgame.se_flat_world_height + widget - CSCEN_FLAT_LAND_HEIGHT_TEXT, 0, MAX_TILE_HEIGHT);
}
_left_button_clicked = false;
break;
case CSCEN_FLAT_LAND_HEIGHT_TEXT: // Height level text
this->widget_id = CSCEN_FLAT_LAND_HEIGHT_TEXT;
SetDParam(0, _patches_newgame.se_flat_world_height);
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_FLAT_WORLD_HEIGHT_QUERY_CAPT, 3, 100, this, CS_NUMERAL);
break;
}
}
case CSCEN_START_DATE_TEXT: // Year text virtual void OnDropdownSelect(int widget, int index)
WP(w, generate_d).widget_id = CSCEN_START_DATE_TEXT; {
SetDParam(0, _patches_newgame.starting_year); switch (widget) {
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_START_DATE_QUERY_CAPT, 8, 100, w, CS_NUMERAL); case CSCEN_MAPSIZE_X_PULLDOWN: _patches_newgame.map_x = index; break;
break; case CSCEN_MAPSIZE_Y_PULLDOWN: _patches_newgame.map_y = index; break;
}
this->SetDirty();
}
case CSCEN_FLAT_LAND_HEIGHT_DOWN: virtual void OnQueryTextFinished(char *str)
case CSCEN_FLAT_LAND_HEIGHT_UP: // Height level buttons {
/* Don't allow too fast scrolling */ if (!StrEmpty(str)) {
if ((w->flags4 & WF_TIMEOUT_MASK) <= 2 << WF_TIMEOUT_SHL) { int32 value = atoi(str);
w->HandleButtonClick(e->we.click.widget);
w->SetDirty();
_patches_newgame.se_flat_world_height = Clamp(_patches_newgame.se_flat_world_height + e->we.click.widget - CSCEN_FLAT_LAND_HEIGHT_TEXT, 0, MAX_TILE_HEIGHT); switch (this->widget_id) {
} case CSCEN_START_DATE_TEXT:
_left_button_clicked = false; this->InvalidateWidget(CSCEN_START_DATE_TEXT);
_patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
break; break;
case CSCEN_FLAT_LAND_HEIGHT_TEXT: // Height level text case CSCEN_FLAT_LAND_HEIGHT_TEXT:
WP(w, generate_d).widget_id = CSCEN_FLAT_LAND_HEIGHT_TEXT; this->InvalidateWidget(CSCEN_FLAT_LAND_HEIGHT_TEXT);
SetDParam(0, _patches_newgame.se_flat_world_height); _patches_newgame.se_flat_world_height = Clamp(value, 0, MAX_TILE_HEIGHT);
ShowQueryString(STR_CONFIG_PATCHES_INT32, STR_FLAT_WORLD_HEIGHT_QUERY_CAPT, 3, 100, w, CS_NUMERAL);
break; break;
} }
break;
case WE_DROPDOWN_SELECT:
switch (e->we.dropdown.button) {
case CSCEN_MAPSIZE_X_PULLDOWN: _patches_newgame.map_x = e->we.dropdown.index; break;
case CSCEN_MAPSIZE_Y_PULLDOWN: _patches_newgame.map_y = e->we.dropdown.index; break;
}
w->SetDirty();
break;
case WE_ON_EDIT_TEXT: this->SetDirty();
if (!StrEmpty(e->we.edittext.str)) { }
int32 value = atoi(e->we.edittext.str);
switch (WP(w, generate_d).widget_id) {
case CSCEN_START_DATE_TEXT:
w->InvalidateWidget(CSCEN_START_DATE_TEXT);
_patches_newgame.starting_year = Clamp(value, MIN_YEAR, MAX_YEAR);
break;
case CSCEN_FLAT_LAND_HEIGHT_TEXT:
w->InvalidateWidget(CSCEN_FLAT_LAND_HEIGHT_TEXT);
_patches_newgame.se_flat_world_height = Clamp(value, 0, MAX_TILE_HEIGHT);
break;
}
w->SetDirty();
}
break;
} }
} };
static const Widget _create_scenario_widgets[] = { static const Widget _create_scenario_widgets[] = {
{ WWT_CLOSEBOX, RESIZE_NONE, 13, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW}, { WWT_CLOSEBOX, RESIZE_NONE, 13, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW},
@ -796,13 +801,13 @@ static const WindowDesc _create_scenario_desc = {
WC_GENERATE_LANDSCAPE, WC_NONE, WC_GENERATE_LANDSCAPE, WC_NONE,
WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS, WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS,
_create_scenario_widgets, _create_scenario_widgets,
CreateScenarioWndProc, NULL,
}; };
void ShowCreateScenario() void ShowCreateScenario()
{ {
DeleteWindowByClass(WC_GENERATE_LANDSCAPE); DeleteWindowByClass(WC_GENERATE_LANDSCAPE);
AllocateWindowDescFront<Window>(&_create_scenario_desc, GLWP_SCENARIO); new CreateScenarioWindow(&_create_scenario_desc, GLWP_SCENARIO);
} }

684
src/misc_gui.cpp
Unescape Escape View File

@ -44,6 +44,7 @@
#include "newgrf_cargo.h" #include "newgrf_cargo.h"
#include "rail_gui.h" #include "rail_gui.h"
#include "tilehighlight_func.h" #include "tilehighlight_func.h"
#include "querystring_gui.h"
#include "table/sprites.h" #include "table/sprites.h"
#include "table/strings.h" #include "table/strings.h"
@ -878,61 +879,61 @@ void UpdateTextBufferSize(Textbuf *tb)
tb->caretxoffs = tb->width; tb->caretxoffs = tb->width;
} }
int HandleEditBoxKey(Window *w, querystr_d *string, int wid, WindowEvent *e) bool HandleCaret(Textbuf *tb)
{ {
e->we.keypress.cont = false; /* caret changed? */
bool b = !!(_caret_timer & 0x20);
switch (e->we.keypress.keycode) { if (b != tb->caret) {
tb->caret = b;
return true;
}
return false;
}
int QueryString::HandleEditBoxKey(Window *w, int wid, uint16 key, uint16 keycode, bool &cont)
{
cont = false;
switch (keycode) {
case WKC_ESC: return 2; case WKC_ESC: return 2;
case WKC_RETURN: case WKC_NUM_ENTER: return 1; case WKC_RETURN: case WKC_NUM_ENTER: return 1;
case (WKC_CTRL | 'V'): case (WKC_CTRL | 'V'):
if (InsertTextBufferClipboard(&string->text)) w->InvalidateWidget(wid); if (InsertTextBufferClipboard(&this->text)) w->InvalidateWidget(wid);
break; break;
case (WKC_CTRL | 'U'): case (WKC_CTRL | 'U'):
DeleteTextBufferAll(&string->text); DeleteTextBufferAll(&this->text);
w->InvalidateWidget(wid); w->InvalidateWidget(wid);
break; break;
case WKC_BACKSPACE: case WKC_DELETE: case WKC_BACKSPACE: case WKC_DELETE:
if (DeleteTextBufferChar(&string->text, e->we.keypress.keycode)) w->InvalidateWidget(wid); if (DeleteTextBufferChar(&this->text, keycode)) w->InvalidateWidget(wid);
break; break;
case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME: case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME:
if (MoveTextBufferPos(&string->text, e->we.keypress.keycode)) w->InvalidateWidget(wid); if (MoveTextBufferPos(&this->text, keycode)) w->InvalidateWidget(wid);
break; break;
default: default:
if (IsValidChar(e->we.keypress.key, string->afilter)) { if (IsValidChar(key, this->afilter)) {
if (InsertTextBufferChar(&string->text, e->we.keypress.key)) w->InvalidateWidget(wid); if (InsertTextBufferChar(&this->text, key)) w->InvalidateWidget(wid);
} else { // key wasn't caught. Continue only if standard entry specified } else { // key wasn't caught. Continue only if standard entry specified
e->we.keypress.cont = (string->afilter == CS_ALPHANUMERAL); cont = (this->afilter == CS_ALPHANUMERAL);
} }
} }
return 0; return 0;
} }
bool HandleCaret(Textbuf *tb) void QueryString::HandleEditBox(Window *w, int wid)
{
/* caret changed? */
bool b = !!(_caret_timer & 0x20);
if (b != tb->caret) {
tb->caret = b;
return true;
}
return false;
}
void HandleEditBox(Window *w, querystr_d *string, int wid)
{ {
if (HandleCaret(&string->text)) w->InvalidateWidget(wid); if (HandleCaret(&this->text)) w->InvalidateWidget(wid);
} }
void DrawEditBox(Window *w, querystr_d *string, int wid) void QueryString::DrawEditBox(Window *w, int wid)
{ {
const Widget *wi = &w->widget[wid]; const Widget *wi = &w->widget[wid];
@ -957,7 +958,7 @@ void DrawEditBox(Window *w, querystr_d *string, int wid)
/* We will take the current widget length as maximum width, with a small /* We will take the current widget length as maximum width, with a small
* space reserved at the end for the caret to show */ * space reserved at the end for the caret to show */
const Textbuf *tb = &string->text; const Textbuf *tb = &this->text;
delta = (wi->right - wi->left) - tb->width - 10; delta = (wi->right - wi->left) - tb->width - 10;
if (delta > 0) delta = 0; if (delta > 0) delta = 0;
@ -970,6 +971,21 @@ void DrawEditBox(Window *w, querystr_d *string, int wid)
_cur_dpi = old_dpi; _cur_dpi = old_dpi;
} }
int QueryStringBaseWindow::HandleEditBoxKey(int wid, uint16 key, uint16 keycode, bool &cont)
{
return this->QueryString::HandleEditBoxKey(this, wid, key, keycode, cont);
}
void QueryStringBaseWindow::HandleEditBox(int wid)
{
this->QueryString::HandleEditBox(this, wid);
}
void QueryStringBaseWindow::DrawEditBox(int wid)
{
this->QueryString::DrawEditBox(this, wid);
}
enum QueryStringWidgets { enum QueryStringWidgets {
QUERY_STR_WIDGET_TEXT = 3, QUERY_STR_WIDGET_TEXT = 3,
QUERY_STR_WIDGET_CANCEL, QUERY_STR_WIDGET_CANCEL,
@ -977,69 +993,79 @@ enum QueryStringWidgets {
}; };
static void QueryStringWndProc(Window *w, WindowEvent *e) struct QueryStringWindow : public QueryStringBaseWindow
{ {
querystr_d *qs = &WP(w, querystr_d); Window *parent;
switch (e->event) { QueryStringWindow(const WindowDesc *desc, Window *parent) : QueryStringBaseWindow(desc), parent(parent)
case WE_CREATE: {
SetBit(_no_scroll, SCROLL_EDIT); SetBit(_no_scroll, SCROLL_EDIT);
break;
case WE_PAINT: this->FindWindowPlacementAndResize(desc);
SetDParam(0, qs->caption); }
DrawWindowWidgets(w);
DrawEditBox(w, qs, QUERY_STR_WIDGET_TEXT); virtual void OnPaint()
break; {
SetDParam(0, this->caption);
DrawWindowWidgets(this);
case WE_CLICK: this->DrawEditBox(QUERY_STR_WIDGET_TEXT);
switch (e->we.click.widget) { }
case QUERY_STR_WIDGET_TEXT:
ShowOnScreenKeyboard(w, &WP(w, querystr_d), QUERY_STR_WIDGET_TEXT, QUERY_STR_WIDGET_CANCEL, QUERY_STR_WIDGET_OK); void OnOk()
break; {
if (this->orig == NULL || strcmp(this->text.buf, this->orig) != 0) {
case QUERY_STR_WIDGET_OK: /* If the parent is NULL, the editbox is handled by general function
press_ok:; * HandleOnEditText */
if (qs->orig == NULL || strcmp(qs->text.buf, qs->orig) != 0) { if (this->parent != NULL) {
Window *parent = w->parent; this->parent->OnQueryTextFinished(this->text.buf);
qs->handled = true; } else {
HandleOnEditText(this->text.buf);
/* If the parent is NULL, the editbox is handled by general function
* HandleOnEditText */
if (parent != NULL) {
parent->OnQueryTextFinished(qs->text.buf);
} else {
HandleOnEditText(qs->text.buf);
}
}
/* Fallthrough */
case QUERY_STR_WIDGET_CANCEL:
delete w;
break;
} }
break; }
}
case WE_MOUSELOOP: virtual void OnClick(Point pt, int widget)
HandleEditBox(w, qs, QUERY_STR_WIDGET_TEXT); {
break; switch (widget) {
case QUERY_STR_WIDGET_TEXT:
ShowOnScreenKeyboard(this, QUERY_STR_WIDGET_TEXT, QUERY_STR_WIDGET_CANCEL, QUERY_STR_WIDGET_OK);
break;
case WE_KEYPRESS: case QUERY_STR_WIDGET_OK:
switch (HandleEditBoxKey(w, qs, QUERY_STR_WIDGET_TEXT, e)) { this->OnOk();
case 1: goto press_ok; // Enter pressed, confirms change /* Fallthrough */
case 2: delete w; break; // ESC pressed, closes window, abandons changes case QUERY_STR_WIDGET_CANCEL:
} delete this;
break; break;
}
}
case WE_DESTROY: // Call cancellation of query, if we have not handled it before virtual void OnMouseLoop()
if (!qs->handled && w->parent != NULL) { {
qs->handled = true; this->HandleEditBox(QUERY_STR_WIDGET_TEXT);
w->parent->OnQueryTextFinished(NULL);
}
ClrBit(_no_scroll, SCROLL_EDIT);
break;
} }
}
virtual bool OnKeyPress(uint16 key, uint16 keycode)
{
bool cont;
switch (this->HandleEditBoxKey(QUERY_STR_WIDGET_TEXT, key, keycode, cont)) {
case 1: this->OnOk(); // Enter pressed, confirms change
/* FALL THROUGH */
case 2: delete this; break; // ESC pressed, closes window, abandons changes
}
return cont;
}
~QueryStringWindow()
{
if (!this->handled && this->parent != NULL) {
this->handled = true;
this->parent->OnQueryTextFinished(NULL);
}
ClrBit(_no_scroll, SCROLL_EDIT);
}
};
static const Widget _query_string_widgets[] = { static const Widget _query_string_widgets[] = {
{ WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW}, { WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW},
@ -1056,12 +1082,9 @@ static const WindowDesc _query_string_desc = {
WC_QUERY_STRING, WC_NONE, WC_QUERY_STRING, WC_NONE,
WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET, WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,
_query_string_widgets, _query_string_widgets,
QueryStringWndProc NULL
}; };
char _edit_str_buf[64];
char _orig_str_buf[lengthof(_edit_str_buf)];
/** Show a query popup window with a textbox in it. /** Show a query popup window with a textbox in it.
* @param str StringID for the text shown in the textbox * @param str StringID for the text shown in the textbox
* @param caption StringID of text shown in caption of querywindow * @param caption StringID of text shown in caption of querywindow
@ -1075,28 +1098,27 @@ void ShowQueryString(StringID str, StringID caption, uint maxlen, uint maxwidth,
{ {
uint realmaxlen = maxlen & ~0x1000; uint realmaxlen = maxlen & ~0x1000;
assert(realmaxlen < lengthof(_edit_str_buf));
DeleteWindowById(WC_QUERY_STRING, 0); DeleteWindowById(WC_QUERY_STRING, 0);
DeleteWindowById(WC_SAVELOAD, 0); DeleteWindowById(WC_SAVELOAD, 0);
Window *w = new Window(&_query_string_desc); QueryStringWindow *w = new QueryStringWindow(&_query_string_desc, parent);
w->parent = parent;
assert(realmaxlen < lengthof(w->edit_str_buf));
GetString(_edit_str_buf, str, lastof(_edit_str_buf)); GetString(w->edit_str_buf, str, lastof(w->edit_str_buf));
_edit_str_buf[realmaxlen - 1] = '\0'; w->edit_str_buf[realmaxlen - 1] = '\0';
if (maxlen & 0x1000) { if (maxlen & 0x1000) {
WP(w, querystr_d).orig = NULL; w->orig = NULL;
} else { } else {
strecpy(_orig_str_buf, _edit_str_buf, lastof(_orig_str_buf)); strecpy(w->orig_str_buf, w->edit_str_buf, lastof(w->orig_str_buf));
WP(w, querystr_d).orig = _orig_str_buf; w->orig = w->orig_str_buf;
} }
w->LowerWidget(QUERY_STR_WIDGET_TEXT); w->LowerWidget(QUERY_STR_WIDGET_TEXT);
WP(w, querystr_d).caption = caption; w->caption = caption;
WP(w, querystr_d).afilter = afilter; w->afilter = afilter;
InitializeTextBuffer(&WP(w, querystr_d).text, _edit_str_buf, realmaxlen, maxwidth); InitializeTextBuffer(&w->text, w->edit_str_buf, realmaxlen, maxwidth);
} }
@ -1306,230 +1328,276 @@ static void MakeSortedSaveGameList()
} }
} }
static void GenerateFileName()
{
/* Check if we are not a spectator who wants to generate a name..
Let's use the name of player #0 for now. */
const Player *p = GetPlayer(IsValidPlayer(_local_player) ? _local_player : PLAYER_FIRST);
SetDParam(0, p->index);
SetDParam(1, _date);
GetString(_edit_str_buf, STR_4004, lastof(_edit_str_buf));
SanitizeFilename(_edit_str_buf);
}
extern void StartupEngines(); extern void StartupEngines();
static void SaveLoadDlgWndProc(Window *w, WindowEvent *e) struct SaveLoadWindow : public QueryStringBaseWindow {
{ FiosItem o_dir;
static FiosItem o_dir;
switch (e->event) { void GenerateFileName()
case WE_CREATE: // Set up OPENTTD button {
w->vscroll.cap = 10; /* Check if we are not a spectator who wants to generate a name..
w->resize.step_width = 2; Let's use the name of player #0 for now. */
w->resize.step_height = 10; const Player *p = GetPlayer(IsValidPlayer(_local_player) ? _local_player : PLAYER_FIRST);
o_dir.type = FIOS_TYPE_DIRECT; SetDParam(0, p->index);
switch (_saveload_mode) { SetDParam(1, _date);
case SLD_SAVE_GAME: GetString(this->edit_str_buf, STR_4004, lastof(this->edit_str_buf));
case SLD_LOAD_GAME: SanitizeFilename(this->edit_str_buf);
FioGetDirectory(o_dir.name, lengthof(o_dir.name), SAVE_DIR); }
break;
case SLD_SAVE_SCENARIO:
case SLD_LOAD_SCENARIO:
FioGetDirectory(o_dir.name, lengthof(o_dir.name), SCENARIO_DIR);
break;
case SLD_LOAD_HEIGHTMAP:
FioGetDirectory(o_dir.name, lengthof(o_dir.name), HEIGHTMAP_DIR);
break;
default:
ttd_strlcpy(o_dir.name, _personal_dir, lengthof(o_dir.name));
}
break;
case WE_PAINT: { SaveLoadWindow(const WindowDesc *desc, SaveLoadDialogMode mode) : QueryStringBaseWindow(desc)
int pos; {
int y; static const StringID saveload_captions[] = {
STR_4001_LOAD_GAME,
STR_0298_LOAD_SCENARIO,
STR_4000_SAVE_GAME,
STR_0299_SAVE_SCENARIO,
STR_LOAD_HEIGHTMAP,
};
SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, VHM_NONE, WC_MAIN_WINDOW, 0);
SetBit(_no_scroll, SCROLL_SAVE);
/* Use an array to define what will be the current file type being handled
* by current file mode */
switch (mode) {
case SLD_SAVE_GAME: this->GenerateFileName(); break;
case SLD_SAVE_SCENARIO: strcpy(this->edit_str_buf, "UNNAMED"); break;
default: break;
}
SetVScrollCount(w, _fios_num); assert((uint)mode < lengthof(saveload_captions));
DrawWindowWidgets(w);
DrawFiosTexts(w->width);
if (_savegame_sort_dirty) { this->widget[1].data = saveload_captions[mode];
_savegame_sort_dirty = false; this->LowerWidget(7);
MakeSortedSaveGameList();
}
GfxFillRect(w->widget[7].left + 1, w->widget[7].top + 1, w->widget[7].right, w->widget[7].bottom, 0xD7); this->afilter = CS_ALPHANUMERAL;
DrawSortButtonState(w, _savegame_sort_order & SORT_BY_NAME ? 2 : 3, _savegame_sort_order & SORT_DESCENDING ? SBS_DOWN : SBS_UP); InitializeTextBuffer(&this->text, this->edit_str_buf, lengthof(this->edit_str_buf), 240);
y = w->widget[7].top + 1; /* pause is only used in single-player, non-editor mode, non-menu mode. It
for (pos = w->vscroll.pos; pos < _fios_num; pos++) { * will be unpaused in the WE_DESTROY event handler. */
const FiosItem *item = _fios_list + pos; if (_game_mode != GM_MENU && !_networking && _game_mode != GM_EDITOR) {
if (_pause_game >= 0) DoCommandP(0, 1, 0, NULL, CMD_PAUSE);
}
DoDrawStringTruncated(item->title, 4, y, _fios_colors[item->type], w->width - 18); BuildFileList();
y += 10;
if (y >= w->vscroll.cap * 10 + w->widget[7].top + 1) break;
}
if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) { ResetObjectToPlace();
DrawEditBox(w, &WP(w, querystr_d), 10);
} o_dir.type = FIOS_TYPE_DIRECT;
break; switch (_saveload_mode) {
case SLD_SAVE_GAME:
case SLD_LOAD_GAME:
FioGetDirectory(o_dir.name, lengthof(o_dir.name), SAVE_DIR);
break;
case SLD_SAVE_SCENARIO:
case SLD_LOAD_SCENARIO:
FioGetDirectory(o_dir.name, lengthof(o_dir.name), SCENARIO_DIR);
break;
case SLD_LOAD_HEIGHTMAP:
FioGetDirectory(o_dir.name, lengthof(o_dir.name), HEIGHTMAP_DIR);
break;
default:
ttd_strlcpy(o_dir.name, _personal_dir, lengthof(o_dir.name));
} }
case WE_CLICK: this->vscroll.cap = 10;
switch (e->we.click.widget) { this->resize.step_width = 2;
case 2: // Sort save names by name this->resize.step_height = 10;
_savegame_sort_order = (_savegame_sort_order == SORT_BY_NAME) ?
SORT_BY_NAME | SORT_DESCENDING : SORT_BY_NAME;
_savegame_sort_dirty = true;
w->SetDirty();
break;
case 3: // Sort save names by date
_savegame_sort_order = (_savegame_sort_order == SORT_BY_DATE) ?
SORT_BY_DATE | SORT_DESCENDING : SORT_BY_DATE;
_savegame_sort_dirty = true;
w->SetDirty();
break;
case 6: // OpenTTD 'button', jumps to OpenTTD directory
FiosBrowseTo(&o_dir);
w->SetDirty();
BuildFileList();
break;
case 7: { // Click the listbox
int y = (e->we.click.pt.y - w->widget[e->we.click.widget].top - 1) / 10;
char *name;
const FiosItem *file;
if (y < 0 || (y += w->vscroll.pos) >= w->vscroll.count) return;
file = _fios_list + y;
name = FiosBrowseTo(file);
if (name != NULL) {
if (_saveload_mode == SLD_LOAD_GAME || _saveload_mode == SLD_LOAD_SCENARIO) {
_switch_mode = (_game_mode == GM_EDITOR) ? SM_LOAD_SCENARIO : SM_LOAD;
SetFiosType(file->type);
ttd_strlcpy(_file_to_saveload.name, name, sizeof(_file_to_saveload.name));
ttd_strlcpy(_file_to_saveload.title, file->title, sizeof(_file_to_saveload.title));
delete w;
} else if (_saveload_mode == SLD_LOAD_HEIGHTMAP) {
SetFiosType(file->type);
ttd_strlcpy(_file_to_saveload.name, name, sizeof(_file_to_saveload.name));
ttd_strlcpy(_file_to_saveload.title, file->title, sizeof(_file_to_saveload.title));
delete w;
ShowHeightmapLoad();
} else {
/* SLD_SAVE_GAME, SLD_SAVE_SCENARIO copy clicked name to editbox */
ttd_strlcpy(WP(w, querystr_d).text.buf, file->title, WP(w, querystr_d).text.maxlength);
UpdateTextBufferSize(&WP(w, querystr_d).text);
w->InvalidateWidget(10);
}
} else {
/* Changed directory, need repaint. */
w->SetDirty();
BuildFileList();
}
break;
}
case 10: // edit box this->FindWindowPlacementAndResize(desc);
ShowOnScreenKeyboard(w, &WP(w, querystr_d), e->we.click.widget, 0, 0); }
break;
case 11: case 12: // Delete, Save game virtual ~SaveLoadWindow()
break; {
} /* pause is only used in single-player, non-editor mode, non menu mode */
break; if (!_networking && _game_mode != GM_EDITOR && _game_mode != GM_MENU) {
if (_pause_game >= 0) DoCommandP(0, 0, 0, NULL, CMD_PAUSE);
}
FiosFreeSavegameList();
ClrBit(_no_scroll, SCROLL_SAVE);
}
case WE_MOUSELOOP: virtual void OnPaint()
if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) { {
HandleEditBox(w, &WP(w, querystr_d), 10); int pos;
} int y;
break;
case WE_KEYPRESS: SetVScrollCount(this, _fios_num);
if (e->we.keypress.keycode == WKC_ESC) { DrawWindowWidgets(this);
delete w; DrawFiosTexts(this->width);
return;
}
if ((_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) && if (_savegame_sort_dirty) {
HandleEditBoxKey(w, &WP(w, querystr_d), 10, e) == 1) { // Press Enter _savegame_sort_dirty = false;
w->HandleButtonClick(12); MakeSortedSaveGameList();
} }
break;
GfxFillRect(this->widget[7].left + 1, this->widget[7].top + 1, this->widget[7].right, this->widget[7].bottom, 0xD7);
DrawSortButtonState(this, _savegame_sort_order & SORT_BY_NAME ? 2 : 3, _savegame_sort_order & SORT_DESCENDING ? SBS_DOWN : SBS_UP);
y = this->widget[7].top + 1;
for (pos = this->vscroll.pos; pos < _fios_num; pos++) {
const FiosItem *item = _fios_list + pos;
DoDrawStringTruncated(item->title, 4, y, _fios_colors[item->type], this->width - 18);
y += 10;
if (y >= this->vscroll.cap * 10 + this->widget[7].top + 1) break;
}
if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {
this->DrawEditBox(10);
}
}
virtual void OnClick(Point pt, int widget)
{
switch (widget) {
case 2: // Sort save names by name
_savegame_sort_order = (_savegame_sort_order == SORT_BY_NAME) ?
SORT_BY_NAME | SORT_DESCENDING : SORT_BY_NAME;
_savegame_sort_dirty = true;
this->SetDirty();
break;
case 3: // Sort save names by date
_savegame_sort_order = (_savegame_sort_order == SORT_BY_DATE) ?
SORT_BY_DATE | SORT_DESCENDING : SORT_BY_DATE;
_savegame_sort_dirty = true;
this->SetDirty();
break;
case 6: // OpenTTD 'button', jumps to OpenTTD directory
FiosBrowseTo(&o_dir);
this->SetDirty();
BuildFileList();
break;
case WE_TIMEOUT: case 7: { // Click the listbox
/* This test protects against using widgets 11 and 12 which are only available int y = (pt.y - this->widget[widget].top - 1) / 10;
* in those two saveload mode */ char *name;
if (!(_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO)) break; const FiosItem *file;
if (w->IsWidgetLowered(11)) { // Delete button clicked if (y < 0 || (y += this->vscroll.pos) >= this->vscroll.count) return;
if (!FiosDelete(WP(w, querystr_d).text.buf)) {
ShowErrorMessage(INVALID_STRING_ID, STR_4008_UNABLE_TO_DELETE_FILE, 0, 0); file = _fios_list + y;
name = FiosBrowseTo(file);
if (name != NULL) {
if (_saveload_mode == SLD_LOAD_GAME || _saveload_mode == SLD_LOAD_SCENARIO) {
_switch_mode = (_game_mode == GM_EDITOR) ? SM_LOAD_SCENARIO : SM_LOAD;
SetFiosType(file->type);
ttd_strlcpy(_file_to_saveload.name, name, sizeof(_file_to_saveload.name));
ttd_strlcpy(_file_to_saveload.title, file->title, sizeof(_file_to_saveload.title));
delete this;
} else if (_saveload_mode == SLD_LOAD_HEIGHTMAP) {
SetFiosType(file->type);
ttd_strlcpy(_file_to_saveload.name, name, sizeof(_file_to_saveload.name));
ttd_strlcpy(_file_to_saveload.title, file->title, sizeof(_file_to_saveload.title));
delete this;
ShowHeightmapLoad();
} else {
/* SLD_SAVE_GAME, SLD_SAVE_SCENARIO copy clicked name to editbox */
ttd_strlcpy(this->text.buf, file->title, this->text.maxlength);
UpdateTextBufferSize(&this->text);
this->InvalidateWidget(10);
}
} else { } else {
/* Changed directory, need repaint. */
this->SetDirty();
BuildFileList(); BuildFileList();
/* Reset file name to current date on successful delete */
if (_saveload_mode == SLD_SAVE_GAME) GenerateFileName();
} }
break;
}
UpdateTextBufferSize(&WP(w, querystr_d).text); case 10: // edit box
w->SetDirty(); ShowOnScreenKeyboard(this, widget, 0, 0);
} else if (w->IsWidgetLowered(12)) { // Save button clicked break;
_switch_mode = SM_SAVE;
FiosMakeSavegameName(_file_to_saveload.name, WP(w, querystr_d).text.buf, sizeof(_file_to_saveload.name));
/* In the editor set up the vehicle engines correctly (date might have changed) */ case 11: case 12: // Delete, Save game
if (_game_mode == GM_EDITOR) StartupEngines(); break;
} }
break; }
case WE_DESTROY: virtual void OnMouseLoop()
/* pause is only used in single-player, non-editor mode, non menu mode */ {
if (!_networking && _game_mode != GM_EDITOR && _game_mode != GM_MENU) { if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {
if (_pause_game >= 0) DoCommandP(0, 0, 0, NULL, CMD_PAUSE); this->HandleEditBox(10);
} }
FiosFreeSavegameList(); }
ClrBit(_no_scroll, SCROLL_SAVE);
break; virtual bool OnKeyPress(uint16 key, uint16 keycode)
{
if (keycode == WKC_ESC) {
delete this;
return false;
}
bool cont = true;
if ((_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) &&
this->HandleEditBoxKey(10, key, keycode, cont) == 1) { // Press Enter
this->HandleButtonClick(12);
}
return cont;
}
virtual void OnTimeout()
{
/* This test protects against using widgets 11 and 12 which are only available
* in those two saveload mode */
if (!(_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO)) return;
case WE_RESIZE: { if (this->IsWidgetLowered(11)) { // Delete button clicked
/* Widget 2 and 3 have to go with halve speed, make it so obiwan */ if (!FiosDelete(this->text.buf)) {
uint diff = e->we.sizing.diff.x / 2; ShowErrorMessage(INVALID_STRING_ID, STR_4008_UNABLE_TO_DELETE_FILE, 0, 0);
w->widget[2].right += diff; } else {
w->widget[3].left += diff; BuildFileList();
w->widget[3].right += e->we.sizing.diff.x; /* Reset file name to current date on successful delete */
if (_saveload_mode == SLD_SAVE_GAME) GenerateFileName();
/* Same for widget 11 and 12 in save-dialog */
if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {
w->widget[11].right += diff;
w->widget[12].left += diff;
w->widget[12].right += e->we.sizing.diff.x;
} }
w->vscroll.cap += e->we.sizing.diff.y / 10; UpdateTextBufferSize(&this->text);
} break; this->SetDirty();
} else if (this->IsWidgetLowered(12)) { // Save button clicked
_switch_mode = SM_SAVE;
FiosMakeSavegameName(_file_to_saveload.name, this->text.buf, sizeof(_file_to_saveload.name));
/* In the editor set up the vehicle engines correctly (date might have changed) */
if (_game_mode == GM_EDITOR) StartupEngines();
}
} }
}
virtual void OnResize(Point new_size, Point delta)
{
/* Widget 2 and 3 have to go with halve speed, make it so obiwan */
uint diff = delta.x / 2;
this->widget[2].right += diff;
this->widget[3].left += diff;
this->widget[3].right += delta.x;
/* Same for widget 11 and 12 in save-dialog */
if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {
this->widget[11].right += diff;
this->widget[12].left += diff;
this->widget[12].right += delta.x;
}
this->vscroll.cap += delta.y / 10;
}
};
static const WindowDesc _load_dialog_desc = { static const WindowDesc _load_dialog_desc = {
WDP_CENTER, WDP_CENTER, 257, 154, 257, 294, WDP_CENTER, WDP_CENTER, 257, 154, 257, 294,
WC_SAVELOAD, WC_NONE, WC_SAVELOAD, WC_NONE,
WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE, WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,
_load_dialog_widgets, _load_dialog_widgets,
SaveLoadDlgWndProc, NULL,
}; };
static const WindowDesc _save_dialog_desc = { static const WindowDesc _save_dialog_desc = {
@ -1537,7 +1605,7 @@ static const WindowDesc _save_dialog_desc = {
WC_SAVELOAD, WC_NONE, WC_SAVELOAD, WC_NONE,
WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE, WDF_STD_TOOLTIPS | WDF_DEF_WIDGET | WDF_STD_BTN | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,
_save_dialog_widgets, _save_dialog_widgets,
SaveLoadDlgWndProc, NULL,
}; };
/** These values are used to convert the file/operations mode into a corresponding file type. /** These values are used to convert the file/operations mode into a corresponding file type.
@ -1553,50 +1621,22 @@ static const FileType _file_modetotype[] = {
void ShowSaveLoadDialog(SaveLoadDialogMode mode) void ShowSaveLoadDialog(SaveLoadDialogMode mode)
{ {
static const StringID saveload_captions[] = {
STR_4001_LOAD_GAME,
STR_0298_LOAD_SCENARIO,
STR_4000_SAVE_GAME,
STR_0299_SAVE_SCENARIO,
STR_LOAD_HEIGHTMAP,
};
const WindowDesc *sld = &_save_dialog_desc;
SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, VHM_NONE, WC_MAIN_WINDOW, 0);
DeleteWindowById(WC_QUERY_STRING, 0); DeleteWindowById(WC_QUERY_STRING, 0);
DeleteWindowById(WC_SAVELOAD, 0); DeleteWindowById(WC_SAVELOAD, 0);
_saveload_mode = mode; const WindowDesc *sld;
SetBit(_no_scroll, SCROLL_SAVE);
/* Use an array to define what will be the current file type being handled
* by current file mode */
_file_to_saveload.filetype = _file_modetotype[mode];
switch (mode) { switch (mode) {
case SLD_SAVE_GAME: GenerateFileName(); break; case SLD_SAVE_GAME:
case SLD_SAVE_SCENARIO: strcpy(_edit_str_buf, "UNNAMED"); break; case SLD_SAVE_SCENARIO:
default: sld = &_load_dialog_desc; break; sld = &_save_dialog_desc; break;
} default:
sld = &_load_dialog_desc; break;
assert((uint)mode < lengthof(saveload_captions));
Window *w = new Window(sld);
w->widget[1].data = saveload_captions[mode];
w->LowerWidget(7);
WP(w, querystr_d).afilter = CS_ALPHANUMERAL;
InitializeTextBuffer(&WP(w, querystr_d).text, _edit_str_buf, lengthof(_edit_str_buf), 240);
/* pause is only used in single-player, non-editor mode, non-menu mode. It
* will be unpaused in the WE_DESTROY event handler. */
if (_game_mode != GM_MENU && !_networking && _game_mode != GM_EDITOR) {
if (_pause_game >= 0) DoCommandP(0, 1, 0, NULL, CMD_PAUSE);
} }
BuildFileList(); _saveload_mode = mode;
_file_to_saveload.filetype = _file_modetotype[mode];
ResetObjectToPlace(); new SaveLoadWindow(sld, mode);
} }
void RedrawAutosave() void RedrawAutosave()

1627
src/network/network_gui.cpp
View File

File diff suppressed because it is too large Load Diff

285
src/osk_gui.cpp
Unescape Escape View File

@ -12,20 +12,11 @@
#include "debug.h" #include "debug.h"
#include "window_func.h" #include "window_func.h"
#include "gfx_func.h" #include "gfx_func.h"
#include "querystring_gui.h"
#include "table/sprites.h" #include "table/sprites.h"
#include "table/strings.h" #include "table/strings.h"
struct osk_d {
querystr_d *qs; // text-input
int text_btn; // widget number of parent's text field
int ok_btn; // widget number of parent's ok button (=0 when ok shouldn't be passed on)
int cancel_btn; // widget number of parent's cancel button (=0 when cancel shouldn't be passed on; text will be reverted to original)
Textbuf *text; // pointer to parent's textbuffer (to update caret position)
char *orig; // the original text, in case we cancel
};
assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(osk_d));
enum OskWidgets { enum OskWidgets {
OSK_WIDGET_TEXT = 3, OSK_WIDGET_TEXT = 3,
OSK_WIDGET_CANCEL = 5, OSK_WIDGET_CANCEL = 5,
@ -50,142 +41,162 @@ enum {
}; };
static byte _keystate = KEYS_NONE; static byte _keystate = KEYS_NONE;
/* struct OskWindow : public Window {
* Only show valid characters; do not show characters that would QueryString *qs; ///< text-input
* only insert a space when we have a spacebar to do that or int text_btn; ///< widget number of parent's text field
* characters that are not allowed to be entered. int ok_btn; ///< widget number of parent's ok button (=0 when ok shouldn't be passed on)
*/ int cancel_btn; ///< widget number of parent's cancel button (=0 when cancel shouldn't be passed on; text will be reverted to original)
static void ChangeOskDiabledState(Window *w, const querystr_d *qs, bool shift) Textbuf *text; ///< pointer to parent's textbuffer (to update caret position)
{ char orig_str_buf[64]; ///< Original string.
for (uint i = 0; i < OSK_KEYBOARD_ENTRIES; i++) {
w->SetWidgetDisabledState(OSK_WIDGET_LETTERS + i, OskWindow(const WindowDesc *desc, QueryStringBaseWindow *parent, int button, int cancel, int ok) : Window(desc)
!IsValidChar(_keyboard[shift][i], qs->afilter) || _keyboard[shift][i] == ' '); {
this->parent = parent;
assert(parent != NULL);
if (parent->widget[button].data != 0) parent->caption = parent->widget[button].data;
this->qs = parent;
this->text_btn = button;
this->cancel_btn = cancel;
this->ok_btn = ok;
this->text = &parent->text;
/* make a copy in case we need to reset later */
strcpy(this->orig_str_buf, this->qs->text.buf);
SetBit(_no_scroll, SCROLL_EDIT);
/* Not needed by default. */
this->DisableWidget(OSK_WIDGET_SPECIAL);
this->FindWindowPlacementAndResize(desc);
} }
w->SetWidgetDisabledState(OSK_WIDGET_SPACE, !IsValidChar(' ', qs->afilter));
}
/* on screen keyboard */ /**
static void OskWndProc(Window *w, WindowEvent *e) * Only show valid characters; do not show characters that would
{ * only insert a space when we have a spacebar to do that or
querystr_d *qs = WP(w, osk_d).qs; * characters that are not allowed to be entered.
*/
void ChangeOskDiabledState(bool shift)
{
for (uint i = 0; i < OSK_KEYBOARD_ENTRIES; i++) {
this->SetWidgetDisabledState(OSK_WIDGET_LETTERS + i,
!IsValidChar(_keyboard[shift][i], this->qs->afilter) || _keyboard[shift][i] == ' ');
}
this->SetWidgetDisabledState(OSK_WIDGET_SPACE, !IsValidChar(' ', this->qs->afilter));
}
virtual void OnPaint()
{
bool shift = HasBit(_keystate, KEYS_CAPS) ^ HasBit(_keystate, KEYS_SHIFT);
this->LowerWidget(OSK_WIDGET_TEXT);
this->SetWidgetLoweredState(OSK_WIDGET_SHIFT, HasBit(_keystate, KEYS_SHIFT));
this->SetWidgetLoweredState(OSK_WIDGET_CAPS, HasBit(_keystate, KEYS_CAPS));
switch (e->event) { this->ChangeOskDiabledState(shift);
case WE_CREATE:
SetBit(_no_scroll, SCROLL_EDIT);
/* Not needed by default. */
w->DisableWidget(OSK_WIDGET_SPECIAL);
break;
case WE_PAINT: { SetDParam(0, this->qs->caption);
DrawWindowWidgets(this);
for (uint i = 0; i < OSK_KEYBOARD_ENTRIES; i++) {
DrawCharCentered(_keyboard[shift][i],
this->widget[OSK_WIDGET_LETTERS + i].left + 8,
this->widget[OSK_WIDGET_LETTERS + i].top + 3,
TC_BLACK);
}
this->qs->DrawEditBox(this, OSK_WIDGET_TEXT);
}
virtual void OnClick(Point pt, int widget)
{
/* clicked a letter */
if (widget >= OSK_WIDGET_LETTERS) {
bool shift = HasBit(_keystate, KEYS_CAPS) ^ HasBit(_keystate, KEYS_SHIFT); bool shift = HasBit(_keystate, KEYS_CAPS) ^ HasBit(_keystate, KEYS_SHIFT);
w->LowerWidget(OSK_WIDGET_TEXT); WChar c = _keyboard[shift][widget - OSK_WIDGET_LETTERS];
w->SetWidgetLoweredState(OSK_WIDGET_SHIFT, HasBit(_keystate, KEYS_SHIFT));
w->SetWidgetLoweredState(OSK_WIDGET_CAPS, HasBit(_keystate, KEYS_CAPS));
ChangeOskDiabledState(w, qs, shift); if (!IsValidChar(c, this->qs->afilter)) return;
SetDParam(0, qs->caption); if (InsertTextBufferChar(&this->qs->text, c)) this->InvalidateWidget(OSK_WIDGET_TEXT);
DrawWindowWidgets(w);
for (uint i = 0; i < OSK_KEYBOARD_ENTRIES; i++) { if (HasBit(_keystate, KEYS_SHIFT)) {
DrawCharCentered(_keyboard[shift][i], ToggleBit(_keystate, KEYS_SHIFT);
w->widget[OSK_WIDGET_LETTERS + i].left + 8, this->widget[OSK_WIDGET_SHIFT].color = HasBit(_keystate, KEYS_SHIFT) ? 15 : 14;
w->widget[OSK_WIDGET_LETTERS + i].top + 3, this->SetDirty();
TC_BLACK);
} }
return;
DrawEditBox(w, qs, OSK_WIDGET_TEXT);
break;
} }
case WE_CLICK: switch (widget) {
/* clicked a letter */ case OSK_WIDGET_BACKSPACE:
if (e->we.click.widget >= OSK_WIDGET_LETTERS) { if (DeleteTextBufferChar(&this->qs->text, WKC_BACKSPACE)) this->InvalidateWidget(OSK_WIDGET_TEXT);
bool shift = HasBit(_keystate, KEYS_CAPS) ^ HasBit(_keystate, KEYS_SHIFT); break;
WChar c = _keyboard[shift][e->we.click.widget - OSK_WIDGET_LETTERS]; case OSK_WIDGET_SPECIAL:
/*
* Anything device specific can go here.
* The button itself is hidden by default, and when you need it you
* can not hide it in the create event.
*/
break;
if (!IsValidChar(c, qs->afilter)) break; case OSK_WIDGET_CAPS:
ToggleBit(_keystate, KEYS_CAPS);
this->SetDirty();
break;
if (InsertTextBufferChar(&qs->text, c)) w->InvalidateWidget(OSK_WIDGET_TEXT); case OSK_WIDGET_SHIFT:
ToggleBit(_keystate, KEYS_SHIFT);
this->SetDirty();
break;
if (HasBit(_keystate, KEYS_SHIFT)) { case OSK_WIDGET_SPACE:
ToggleBit(_keystate, KEYS_SHIFT); if (InsertTextBufferChar(&this->qs->text, ' ')) this->InvalidateWidget(OSK_WIDGET_TEXT);
w->widget[OSK_WIDGET_SHIFT].color = HasBit(_keystate, KEYS_SHIFT) ? 15 : 14;
w->SetDirty();
}
break; break;
}
switch (e->we.click.widget) { case OSK_WIDGET_LEFT:
case OSK_WIDGET_BACKSPACE: if (MoveTextBufferPos(&this->qs->text, WKC_LEFT)) this->InvalidateWidget(OSK_WIDGET_TEXT);
if (DeleteTextBufferChar(&qs->text, WKC_BACKSPACE)) w->InvalidateWidget(OSK_WIDGET_TEXT); break;
break;
case OSK_WIDGET_RIGHT:
case OSK_WIDGET_SPECIAL: if (MoveTextBufferPos(&this->qs->text, WKC_RIGHT)) this->InvalidateWidget(OSK_WIDGET_TEXT);
/* break;
* Anything device specific can go here.
* The button itself is hidden by default, and when you need it you case OSK_WIDGET_OK:
* can not hide it in the create event. if (this->qs->orig == NULL || strcmp(this->qs->text.buf, this->qs->orig) != 0) {
*/ /* pass information by simulating a button press on parent window */
break; if (this->ok_btn != 0) {
this->parent->OnClick(pt, this->ok_btn);
case OSK_WIDGET_CAPS:
ToggleBit(_keystate, KEYS_CAPS);
w->SetDirty();
break;
case OSK_WIDGET_SHIFT:
ToggleBit(_keystate, KEYS_SHIFT);
w->SetDirty();
break;
case OSK_WIDGET_SPACE:
if (InsertTextBufferChar(&qs->text, ' ')) w->InvalidateWidget(OSK_WIDGET_TEXT);
break;
case OSK_WIDGET_LEFT:
if (MoveTextBufferPos(&qs->text, WKC_LEFT)) w->InvalidateWidget(OSK_WIDGET_TEXT);
break;
case OSK_WIDGET_RIGHT:
if (MoveTextBufferPos(&qs->text, WKC_RIGHT)) w->InvalidateWidget(OSK_WIDGET_TEXT);
break;
case OSK_WIDGET_OK:
if (qs->orig == NULL || strcmp(qs->text.buf, qs->orig) != 0) {
/* pass information by simulating a button press on parent window */
if (WP(w, osk_d).ok_btn != 0) {
w->parent->OnClick(e->we.click.pt, WP(w, osk_d).ok_btn);
}
}
delete w;
break;
case OSK_WIDGET_CANCEL:
if (WP(w, osk_d).cancel_btn != 0) { // pass a cancel event to the parent window
w->parent->OnClick(e->we.click.pt, WP(w, osk_d).cancel_btn);
/* Window gets deleted when the parent window removes itself. */
} else { // or reset to original string
strcpy(qs->text.buf, WP(w, osk_d).orig);
UpdateTextBufferSize(&qs->text);
MoveTextBufferPos(&qs->text, WKC_END);
delete w;
} }
break; }
} delete this;
/* make sure that the parent window's textbox also gets updated */ break;
if (w->parent != NULL) w->parent->InvalidateWidget(WP(w, osk_d).text_btn);
break; case OSK_WIDGET_CANCEL:
if (this->cancel_btn != 0) { // pass a cancel event to the parent window
case WE_MOUSELOOP: this->parent->OnClick(pt, this->cancel_btn);
HandleEditBox(w, qs, OSK_WIDGET_TEXT); /* Window gets deleted when the parent window removes itself. */
/* make the caret of the parent window also blink */ } else { // or reset to original string
w->parent->InvalidateWidget(WP(w, osk_d).text_btn); strcpy(qs->text.buf, this->orig_str_buf);
break; UpdateTextBufferSize(&qs->text);
MoveTextBufferPos(&qs->text, WKC_END);
delete this;
}
break;
}
/* make sure that the parent window's textbox also gets updated */
if (this->parent != NULL) this->parent->InvalidateWidget(this->text_btn);
} }
}
virtual void OnMouseLoop()
{
this->qs->HandleEditBox(this, OSK_WIDGET_TEXT);
/* make the caret of the parent window also blink */
this->parent->InvalidateWidget(this->text_btn);
}
};
static const Widget _osk_widgets[] = { static const Widget _osk_widgets[] = {
{ WWT_EMPTY, RESIZE_NONE, 0, 0, 0, 0, 0, 0x0, STR_NULL}, { WWT_EMPTY, RESIZE_NONE, 0, 0, 0, 0, 0, 0x0, STR_NULL},
@ -270,7 +281,7 @@ WindowDesc _osk_desc = {
WC_OSK, WC_NONE, WC_OSK, WC_NONE,
WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS, WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,
_osk_widgets, _osk_widgets,
OskWndProc NULL
}; };
/** /**
@ -338,26 +349,10 @@ void GetKeyboardLayout()
* @param ok widget number of parent's ok button (0 if ok events should not * @param ok widget number of parent's ok button (0 if ok events should not
* be passed) * be passed)
*/ */
void ShowOnScreenKeyboard(Window *parent, querystr_d *q, int button, int cancel, int ok) void ShowOnScreenKeyboard(QueryStringBaseWindow *parent, int button, int cancel, int ok)
{ {
DeleteWindowById(WC_OSK, 0); DeleteWindowById(WC_OSK, 0);
Window *w = new Window(&_osk_desc);
w->parent = parent;
assert(parent != NULL);
if (parent->widget[button].data != 0) q->caption = parent->widget[button].data;
WP(w, osk_d).qs = q;
WP(w, osk_d).text_btn = button;
WP(w, osk_d).cancel_btn = cancel;
WP(w, osk_d).ok_btn = ok;
WP(w, osk_d).text = &q->text;
GetKeyboardLayout(); GetKeyboardLayout();
new OskWindow(&_osk_desc, parent, button, cancel, ok);
/* make a copy in case we need to reset later */
strcpy(_orig_str_buf, WP(w, osk_d).qs->text.buf);
WP(w, osk_d).orig = _orig_str_buf;
} }

38
src/querystring_gui.h
Unescape Escape View File

@ -0,0 +1,38 @@
/* $Id$ */
/** @file querystring_gui.h Base for the GUIs that have an edit box in them. */
#ifndef QUERYSTRING_GUI_H
#define QUERYSTRING_GUI_H
#include "textbuf_gui.h"
#include "window_gui.h"
struct QueryString {
StringID caption;
Textbuf text;
const char *orig;
CharSetFilter afilter;
bool handled;
void DrawEditBox(Window *w, int wid);
void HandleEditBox(Window *w, int wid);
int HandleEditBoxKey(Window *w, int wid, uint16 key, uint16 keycode, bool &cont);
};
struct QueryStringBaseWindow : public Window, public QueryString {
char edit_str_buf[64];
char orig_str_buf[64];
QueryStringBaseWindow(const WindowDesc *desc, void *data = NULL, WindowNumber window_number = 0) : Window(desc, data, window_number)
{
}
void DrawEditBox(int wid);
void HandleEditBox(int wid);
int HandleEditBoxKey(int wid, uint16 key, uint16 keycode, bool &cont);
};
void ShowOnScreenKeyboard(QueryStringBaseWindow *parent, int button, int cancel, int ok);
#endif /* QUERYSTRING_GUI_H */

227
src/signs_gui.cpp
Unescape Escape View File

@ -19,6 +19,7 @@
#include "map_func.h" #include "map_func.h"
#include "gfx_func.h" #include "gfx_func.h"
#include "viewport_func.h" #include "viewport_func.h"
#include "querystring_gui.h"
#include "table/strings.h" #include "table/strings.h"
#include "table/sprites.h" #include "table/sprites.h"
@ -143,11 +144,11 @@ void ShowSignList()
} }
} }
/** Edit sign window stuff */ static void RenameSign(SignID index, const char *text)
struct editsign_d : querystr_d { {
SignID cur_sign; _cmd_text = text;
}; DoCommandP(0, index, 0, NULL, CMD_RENAME_SIGN | CMD_MSG(STR_280C_CAN_T_CHANGE_SIGN_NAME));
assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(editsign_d)); }
enum QueryEditSignWidgets { enum QueryEditSignWidgets {
QUERY_EDIT_SIGN_WIDGET_TEXT = 3, QUERY_EDIT_SIGN_WIDGET_TEXT = 3,
@ -158,120 +159,122 @@ enum QueryEditSignWidgets {
QUERY_EDIT_SIGN_WIDGET_NEXT, QUERY_EDIT_SIGN_WIDGET_NEXT,
}; };
static void UpdateSignEditWindow(Window *w, const Sign *si) struct SignWindow : QueryStringBaseWindow {
{ SignID cur_sign;
/* Display an empty string when the sign hasnt been edited yet */
if (si->name != NULL) {
SetDParam(0, si->index);
GetString(_edit_str_buf, STR_SIGN_NAME, lastof(_edit_str_buf));
} else {
GetString(_edit_str_buf, STR_EMPTY, lastof(_edit_str_buf));
}
_edit_str_buf[lengthof(_edit_str_buf) - 1] = '\0';
WP(w, editsign_d).cur_sign = si->index;
InitializeTextBuffer(&WP(w, querystr_d).text, _edit_str_buf, 31, 255); // Allow 31 characters (including \0)
w->InvalidateWidget(QUERY_EDIT_SIGN_WIDGET_TEXT); SignWindow(const WindowDesc *desc, const Sign *si) : QueryStringBaseWindow(desc)
} {
SetBit(_no_scroll, SCROLL_EDIT);
this->caption = STR_280B_EDIT_SIGN_TEXT;
this->afilter = CS_ALPHANUMERAL;
this->LowerWidget(QUERY_EDIT_SIGN_WIDGET_TEXT);
static void RenameSign(SignID index, const char *text) UpdateSignEditWindow(si);
{ }
_cmd_text = text;
DoCommandP(0, index, 0, NULL, CMD_RENAME_SIGN | CMD_MSG(STR_280C_CAN_T_CHANGE_SIGN_NAME));
}
static void QuerySignEditWndProc(Window *w, WindowEvent *e) ~SignWindow()
{ {
editsign_d *qs = &WP(w, editsign_d); ClrBit(_no_scroll, SCROLL_EDIT);
Sign *si; }
uint sign_index = 0;
switch (e->event) { void UpdateSignEditWindow(const Sign *si)
case WE_CREATE: {
SetBit(_no_scroll, SCROLL_EDIT); /* Display an empty string when the sign hasnt been edited yet */
break; if (si->name != NULL) {
SetDParam(0, si->index);
GetString(this->edit_str_buf, STR_SIGN_NAME, lastof(this->edit_str_buf));
} else {
GetString(this->edit_str_buf, STR_EMPTY, lastof(this->edit_str_buf));
}
this->edit_str_buf[lengthof(this->edit_str_buf) - 1] = '\0';
this->cur_sign = si->index;
InitializeTextBuffer(&this->text, this->edit_str_buf, 31, 255); // Allow 31 characters (including \0)
this->InvalidateWidget(QUERY_EDIT_SIGN_WIDGET_TEXT);
}
case WE_PAINT: virtual void OnPaint()
SetDParam(0, qs->caption); {
DrawWindowWidgets(w); SetDParam(0, this->caption);
DrawEditBox(w, qs, QUERY_EDIT_SIGN_WIDGET_TEXT); DrawWindowWidgets(this);
break; this->DrawEditBox(QUERY_EDIT_SIGN_WIDGET_TEXT);
}
case WE_CLICK: virtual void OnClick(Point pt, int widget)
switch (e->we.click.widget) { {
case QUERY_EDIT_SIGN_WIDGET_PREVIOUS: switch (widget) {
if (_sign_sort_dirty) GlobalSortSignList(); case QUERY_EDIT_SIGN_WIDGET_PREVIOUS: {
sign_index = _sign_sort[_num_sign_sort - 1]->index; if (_sign_sort_dirty) GlobalSortSignList();
for (uint i = 1; i < _num_sign_sort; i++) { SignID sign_index = _sign_sort[_num_sign_sort - 1]->index;
if (qs->cur_sign == _sign_sort[i]->index) { for (uint i = 1; i < _num_sign_sort; i++) {
sign_index = _sign_sort[i - 1]->index; if (this->cur_sign == _sign_sort[i]->index) {
break; sign_index = _sign_sort[i - 1]->index;
} break;
} }
si = GetSign(sign_index); }
const Sign *si = GetSign(sign_index);
/* Scroll to sign and reopen window */
ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
UpdateSignEditWindow(w, si);
break;
case QUERY_EDIT_SIGN_WIDGET_NEXT:
if (_sign_sort_dirty) GlobalSortSignList();
sign_index = _sign_sort[0]->index;
for (uint i = 0; i < _num_sign_sort - 1; i++) {
if (qs->cur_sign == _sign_sort[i]->index) {
sign_index = _sign_sort[i + 1]->index;
break;
}
}
si = GetSign(sign_index);
/* Scroll to sign and reopen window */
ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
UpdateSignEditWindow(w, si);
break;
case QUERY_EDIT_SIGN_WIDGET_TEXT:
ShowOnScreenKeyboard(w, qs, e->we.click.widget, QUERY_EDIT_SIGN_WIDGET_CANCEL, QUERY_EDIT_SIGN_WIDGET_OK);
break;
case QUERY_EDIT_SIGN_WIDGET_DELETE: /* Scroll to sign and reopen window */
/* Only need to set the buffer to null, the rest is handled as the OK button */ ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
DeleteTextBufferAll(&qs->text); UpdateSignEditWindow(si);
/* FALL THROUGH */ } break;
case QUERY_EDIT_SIGN_WIDGET_OK: case QUERY_EDIT_SIGN_WIDGET_NEXT: {
RenameSign(qs->cur_sign, qs->text.buf); if (_sign_sort_dirty) GlobalSortSignList();
/* FALL THROUGH */ SignID sign_index = _sign_sort[0]->index;
for (uint i = 0; i < _num_sign_sort - 1; i++) {
case QUERY_EDIT_SIGN_WIDGET_CANCEL: if (this->cur_sign == _sign_sort[i]->index) {
delete w; sign_index = _sign_sort[i + 1]->index;
break; break;
} }
break; }
const Sign *si = GetSign(sign_index);
case WE_KEYPRESS:
switch (HandleEditBoxKey(w, qs, QUERY_EDIT_SIGN_WIDGET_TEXT, e)) {
case 1: // Enter pressed, confirms change
RenameSign(qs->cur_sign, qs->text.buf);
/* FALL THROUGH */
case 2: // ESC pressed, closes window, abandons changes /* Scroll to sign and reopen window */
delete w; ScrollMainWindowToTile(TileVirtXY(si->x, si->y));
break; UpdateSignEditWindow(si);
} } break;
break;
case QUERY_EDIT_SIGN_WIDGET_TEXT:
ShowOnScreenKeyboard(this, widget, QUERY_EDIT_SIGN_WIDGET_CANCEL, QUERY_EDIT_SIGN_WIDGET_OK);
break;
case QUERY_EDIT_SIGN_WIDGET_DELETE:
/* Only need to set the buffer to null, the rest is handled as the OK button */
DeleteTextBufferAll(&this->text);
/* FALL THROUGH */
case QUERY_EDIT_SIGN_WIDGET_OK:
RenameSign(this->cur_sign, this->text.buf);
/* FALL THROUGH */
case QUERY_EDIT_SIGN_WIDGET_CANCEL:
delete this;
break;
}
}
case WE_MOUSELOOP: virtual bool OnKeyPress(uint16 key, uint16 keycode)
HandleEditBox(w, qs, QUERY_EDIT_SIGN_WIDGET_TEXT); {
break; bool cont = true;
switch (this->HandleEditBoxKey(QUERY_EDIT_SIGN_WIDGET_TEXT, key, keycode, cont)) {
case 1: // Enter pressed, confirms change
RenameSign(this->cur_sign, this->text.buf);
/* FALL THROUGH */
case 2: // ESC pressed, closes window, abandons changes
delete this;
break;
}
return cont;
}
case WE_DESTROY: virtual void OnMouseLoop()
ClrBit(_no_scroll, SCROLL_EDIT); {
break; this->HandleEditBox(QUERY_EDIT_SIGN_WIDGET_TEXT);
} }
} };
static const Widget _query_sign_edit_widgets[] = { static const Widget _query_sign_edit_widgets[] = {
{ WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW}, { WWT_CLOSEBOX, RESIZE_NONE, 14, 0, 10, 0, 13, STR_00C5, STR_018B_CLOSE_WINDOW},
@ -292,7 +295,7 @@ static const WindowDesc _query_sign_edit_desc = {
WC_QUERY_STRING, WC_NONE, WC_QUERY_STRING, WC_NONE,
WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET, WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,
_query_sign_edit_widgets, _query_sign_edit_widgets,
QuerySignEditWndProc NULL
}; };
void ShowRenameSignWindow(const Sign *si) void ShowRenameSignWindow(const Sign *si)
@ -301,11 +304,5 @@ void ShowRenameSignWindow(const Sign *si)
DeleteWindowById(WC_QUERY_STRING, 0); DeleteWindowById(WC_QUERY_STRING, 0);
DeleteWindowById(WC_SAVELOAD, 0); DeleteWindowById(WC_SAVELOAD, 0);
Window *w = new Window(&_query_sign_edit_desc); new SignWindow(&_query_sign_edit_desc, si);
WP(w, editsign_d).caption = STR_280B_EDIT_SIGN_TEXT;
WP(w, editsign_d).afilter = CS_ALPHANUMERAL;
w->LowerWidget(QUERY_EDIT_SIGN_WIDGET_TEXT);
UpdateSignEditWindow(w, si);
} }

17
src/textbuf_gui.h
Unescape Escape View File

@ -18,21 +18,6 @@ struct Textbuf {
uint16 caretxoffs; ///< the current position of the caret in pixels uint16 caretxoffs; ///< the current position of the caret in pixels
}; };
struct querystr_d {
StringID caption;
Textbuf text;
const char *orig;
CharSetFilter afilter;
bool handled;
};
assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(querystr_d));
extern char _edit_str_buf[64];
extern char _orig_str_buf[lengthof(_edit_str_buf)];
void DrawEditBox(Window *w, querystr_d *string, int wid);
void HandleEditBox(Window *w, querystr_d *string, int wid);
int HandleEditBoxKey(Window *w, querystr_d *string, int wid, WindowEvent *we);
bool HandleCaret(Textbuf *tb); bool HandleCaret(Textbuf *tb);
void DeleteTextBufferAll(Textbuf *tb); void DeleteTextBufferAll(Textbuf *tb);
@ -56,6 +41,4 @@ static const uint OSK_KEYBOARD_ENTRIES = 50;
*/ */
extern char _keyboard_opt[2][OSK_KEYBOARD_ENTRIES * 4 + 1]; extern char _keyboard_opt[2][OSK_KEYBOARD_ENTRIES * 4 + 1];
void ShowOnScreenKeyboard(Window *parent, querystr_d *q, int button, int cancel, int ok);
#endif /* TEXTBUF_GUI_H */ #endif /* TEXTBUF_GUI_H */

Write Preview
Loading…
Cancel
Save