tlabel_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_label
*
* == Label ==
*
* @macro = label_description
*
* Although the label itself has no event interaction it still has two states.
* The reason is that labels are often used as visual indication of the state
* of the widget it labels.
*
* The following states exist:
* * state_enabled, the label is enabled.
* * state_disabled, the label is disabled.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="label_definition"}
* @end{parent}{name="gui/"}
*/
// Note the order should be the same as the enum tstate is label.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
}
ttoggle_button_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_toggle_button
*
* == Toggle button ==
*
* The definition of a toggle button.
*
* The following states exist:
* * state_enabled, the button is enabled and not selected.
* * state_disabled, the button is disabled and not selected.
* * state_focussed, the mouse is over the button and not selected.
*
* * state_enabled_selected, the button is enabled and selected.
* * state_disabled_selected, the button is disabled and selected.
* * state_focussed_selected, the mouse is over the button and selected.
*/
// Note the order should be the same as the enum tstate in
// toggle_button.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
state.push_back(tstate_definition(cfg.child("state_focussed")));
state.push_back(tstate_definition(cfg.child("state_enabled_selected")));
state.push_back(tstate_definition(cfg.child("state_disabled_selected")));
state.push_back(tstate_definition(cfg.child("state_focussed_selected")));
}
tscrollbar_panel_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, grid()
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_scrollbar_panel
*
* == Scrollbar panel ==
*
* The definition of a panel with scrollbars. A panel is a container hold
* other elements in it's grid. A panel is always enabled and can't be
* disabled. Instead it uses the states as layers to draw on.
*
* @start_table = config
* grid (grid) A grid containing the widgets for main
* widget.
* @end_table
*
* The following layers exist:
* * background, the background of the panel.
* * foreground, the foreground of the panel.
*/
// The panel needs to know the order.
state.push_back(tstate_definition(cfg.child("background")));
state.push_back(tstate_definition(cfg.child("foreground")));
const config &child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
ttext_box_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, text_x_offset(cfg["text_x_offset"])
, text_y_offset(cfg["text_y_offset"])
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_text_box
*
* == Text box ==
*
* The definition of a text box.
*
* The resolution for a text box also contains the following keys:
* @begin{table}{config}
* text_x_offset & f_unsigned & "" & The x offset of the text in the text
* box. This is needed for the code to
* determine where in the text the mouse
* clicks, so it can set the cursor
* properly. $
* text_y_offset & f_unsigned & "" & The y offset of the text in the text
* box. $
* @end{table}
*
* The following states exist:
* * state_enabled, the text box is enabled.
* * state_disabled, the text box is disabled.
* * state_focussed, the text box has the focus of the keyboard.
*/
// Note the order should be the same as the enum tstate in text_box.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
state.push_back(tstate_definition(cfg.child("state_focussed")));
}
ttree_view_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, grid(NULL)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_tree_view
*
* == Tree view ==
*
* @macro = tree_view_description
*
* The documentation is not written yet.
*
* The following states exist:
* * state_enabled, the listbox is enabled.
* * state_disabled, the listbox is disabled.
*/
// Note the order should be the same as the enum tstate is listbox.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
const config &child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_label
*
* == Label ==
*
* @macro = label_description
*
* Although the label itself has no event interaction it still has two states.
* The reason is that labels are often used as visual indication of the state
* of the widget it labels.
*
* The following states exist:
* * state_enabled, the label is enabled.
* * state_disabled, the label is disabled.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="label_definition"}
* @end{parent}{name="gui/"}
*/
tlabel_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
{
// Note the order should be the same as the enum tstate is label.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
}
tbuilder_matrix::tbuilder_matrix(const config& cfg)
: tbuilder_control(cfg)
, vertical_scrollbar_mode(
get_scrollbar_mode(cfg["vertical_scrollbar_mode"]))
, horizontal_scrollbar_mode(
get_scrollbar_mode(cfg["horizontal_scrollbar_mode"]))
, builder_top(NULL)
, builder_bottom(NULL)
, builder_left(NULL)
, builder_right(NULL)
, builder_main(create_builder_widget(cfg.child("main", "[matrix]")))
{
if(const config& top = cfg.child("top")) {
builder_top = new tbuilder_grid(top);
}
if(const config& bottom = cfg.child("bottom")) {
builder_bottom = new tbuilder_grid(bottom);
}
if(const config& left = cfg.child("left")) {
builder_left = new tbuilder_grid(left);
}
if(const config& right = cfg.child("right")) {
builder_right = new tbuilder_grid(right);
}
}
trepeating_button_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_repeating_button
*
* == Repeating button ==
*
* @macro = repeating_button_description
*
* The following states exist:
* * state_enabled, the repeating_button is enabled.
* * state_disabled, the repeating_button is disabled.
* * state_pressed, the left mouse repeating_button is down.
* * state_focussed, the mouse is over the repeating_button.
*
*/
// Note the order should be the same as the enum tstate in
// repeating_button.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
state.push_back(tstate_definition(cfg.child("state_pressed")));
state.push_back(tstate_definition(cfg.child("state_focussed")));
}
builder_listbox::builder_listbox(const config& cfg)
: builder_styled_widget(cfg)
, vertical_scrollbar_mode(get_scrollbar_mode(cfg["vertical_scrollbar_mode"]))
, horizontal_scrollbar_mode(get_scrollbar_mode(cfg["horizontal_scrollbar_mode"]))
, header(nullptr)
, footer(nullptr)
, list_builder(nullptr)
, list_data()
, has_minimum_(cfg["has_minimum"].to_bool(true))
, has_maximum_(cfg["has_maximum"].to_bool(true))
{
if(const config& h = cfg.child("header")) {
header = std::make_shared<builder_grid>(h);
}
if(const config& f = cfg.child("footer")) {
footer = std::make_shared<builder_grid>(f);
}
const config& l = cfg.child("list_definition");
VALIDATE(l, _("No list defined."));
list_builder = std::make_shared<builder_grid>(l);
assert(list_builder);
VALIDATE(list_builder->rows == 1, _("A 'list_definition' should contain one row."));
if(cfg.has_child("list_data")) {
list_data = parse_list_data(cfg.child("list_data"), list_builder->cols);
}
}
void mp_game_settings::set_from_config(const config& game_cfg)
{
const config& mp = game_cfg.child("multiplayer");
const config& rs = game_cfg.child("replay_start");
// if it's a replay the multiplayer section can be in the replay_start tag else fallback to top level
const config& cfg = mp ? mp : rs ? (rs.child("multiplayer") ? rs.child("multiplayer") : game_cfg) : game_cfg;
name = cfg["scenario"].str();
hash = cfg["hash"].str();
mp_era = cfg["mp_era"].str();
mp_scenario = cfg["mp_scenario"].str();
mp_scenario_name = cfg["scenario_name"].str();
mp_campaign = cfg["mp_campaign"].str();
difficulty_define = cfg["difficulty_define"].str();
active_mods = utils::split(cfg["active_mods"], ',');
side_users = utils::map_split(cfg["side_users"]);
show_configure = cfg["enable_configure"].to_bool(true);
show_connect = cfg["enable_connect"].to_bool(true);
xp_modifier = cfg["experience_modifier"];
use_map_settings = cfg["mp_use_map_settings"].to_bool();
random_start_time = cfg["mp_random_start_time"].to_bool();
fog_game = cfg["mp_fog"].to_bool();
shroud_game = cfg["mp_shroud"].to_bool();
mp_countdown = cfg["mp_countdown"].to_bool();
mp_countdown_init_time = cfg["mp_countdown_init_time"];
mp_countdown_turn_bonus = cfg["mp_countdown_turn_bonus"];
mp_countdown_reservoir_time = cfg["mp_countdown_reservoir_time"];
mp_countdown_action_bonus = cfg["mp_countdown_action_bonus"];
num_turns = cfg["mp_num_turns"];
village_gold = cfg["mp_village_gold"];
village_support = cfg["mp_village_support"];
allow_observers = cfg["observer"].to_bool();
shuffle_sides = cfg["shuffle_sides"].to_bool();
saved_game = cfg["savegame"].to_bool();
options = cfg.child_or_empty("options");
}
tmatrix_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, content(new tbuilder_grid(cfg.child("content", "[matrix_definition]")))
{
// Note the order should be the same as the enum tstate in matrix.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_label
*
* == Label ==
*
* @macro = label_description
*
* Although the label itself has no event interaction it still has two states.
* The reason is that labels are often used as visual indication of the state
* of the widget it labels.
*
* Note: The above is outdated, if "link_aware" is enabled then there is interaction.
*
*
* The following states exist:
* * state_enabled, the label is enabled.
* * state_disabled, the label is disabled.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{table}{config}
* link_aware & f_bool & false & Whether the label is link aware. This means
* it is rendered with links highlighted,
* and responds to click events on those
* links. $
* link_color & string & #ffff00 & The color to render links with. This
* string will be used verbatim in pango
* markup for each link. $
* @end{table}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="label_definition"}
* @end{parent}{name="gui/"}
*/
tlabel_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, link_aware(cfg["link_aware"].to_bool(false))
, link_color(cfg["link_color"].str().size() > 0 ? cfg["link_color"].str() : "#ffff00")
{
// Note the order should be the same as the enum tstate is label.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_menu_button
*
* == menu_button ==
*
* @macro = menu_button_description
*
* The following states exist:
* * state_enabled, the menu_button is enabled.
* * state_disabled, the menu_button is disabled.
* * state_pressed, the left mouse menu_button is down.
* * state_focused, the mouse is over the menu_button.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="menu_button_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @begin{tag}{name="state_pressed"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_pressed"}
* @begin{tag}{name="state_focused"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focused"}
* @end{tag}{name="resolution"}
* @end{tag}{name="menu_button_definition"}
* @end{parent}{name="gui/"}
*/
menu_button_definition::resolution::resolution(const config& cfg)
: resolution_definition(cfg)
{
// Note the order should be the same as the enum state_t in menu_button.hpp.
state.emplace_back(cfg.child("state_enabled"));
state.emplace_back(cfg.child("state_disabled"));
state.emplace_back(cfg.child("state_pressed"));
state.emplace_back(cfg.child("state_focused"));
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_repeating_button
*
* == Repeating button ==
*
* @macro = repeating_button_description
*
* The following states exist:
* * state_enabled, the repeating_button is enabled.
* * state_disabled, the repeating_button is disabled.
* * state_pressed, the left mouse repeating_button is down.
* * state_focused, the mouse is over the repeating_button.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="repeating_button_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @begin{tag}{name="state_pressed"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_pressed"}
* @begin{tag}{name="state_focused"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focused"}
* @end{tag}{name="resolution"}
* @end{tag}{name="repeating_button_definition"}
* @end{parent}{name="gui/"}
*/
repeating_button_definition::resolution::resolution(const config& cfg)
: resolution_definition(cfg)
{
// Note the order should be the same as the enum state_t in
// repeating_button.hpp.
state.push_back(state_definition(cfg.child("state_enabled")));
state.push_back(state_definition(cfg.child("state_disabled")));
state.push_back(state_definition(cfg.child("state_pressed")));
state.push_back(state_definition(cfg.child("state_focused")));
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_text_box
*
* == Text box ==
*
* The definition of a text box.
*
* @begin{parent}{name="gui/"}
* @begin{tag}{name="text_box_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* The resolution for a text box also contains the following keys:
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super=generic/widget_definition/resolution}
* @begin{table}{config}
* text_x_offset & f_unsigned & "" & The x offset of the text in the text
* box. This is needed for the code to
* determine where in the text the mouse
* clicks, so it can set the cursor
* properly. $
* text_y_offset & f_unsigned & "" & The y offset of the text in the text
* box. $
* @end{table}
*
* The following states exist:
* * state_enabled, the text box is enabled.
* * state_disabled, the text box is disabled.
* * state_focused, the text box has the focus of the keyboard.
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @begin{tag}{name="state_focused"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focused"}
* @end{tag}{name="resolution"}
* @end{tag}{name="text_box_definition"}
* @end{parent}{name="gui/"}
*/
ttext_box_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, text_x_offset(cfg["text_x_offset"])
, text_y_offset(cfg["text_y_offset"])
{
// Note the order should be the same as the enum tstate in text_box.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
state.push_back(tstate_definition(cfg.child("state_focused")));
}
tscroll_label_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, grid(NULL)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_scroll_label
*
* == Scroll label ==
*
* @macro = scroll_label_description
*
* @begin{parent}{name="gui/"}
* This widget is slower as a normal label widget so only use this widget
* when the scrollbar is required (or expected to become required).
* @begin{tag}{name="scroll_label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{table}{config}
* grid & grid & & A grid containing the widgets for main
* widget. $
* @end{table}
* @allow{link}{name="gui/window/resolution/grid"}
* TODO we need one definition for a vertical scrollbar since this is the second
* time we use it.
*
* @begin{table}{dialog_widgets}
* _content_grid & & grid & m & A grid which should only contain one
* label widget. $
* _scrollbar_grid & & grid & m & A grid for the scrollbar
* (Merge with listbox info.) $
* @end{table}
* @begin{tag}{name="content_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="content_grid"}
* @begin{tag}{name="scrollbar_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="scrollbar_grid"}
* The following states exist:
* * state_enabled, the scroll label is enabled.
* * state_disabled, the scroll label is disabled.
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="scroll_label_definition"}
* @end{parent}{name="gui/"}
*/
// Note the order should be the same as the enum tstate is scroll_label.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
const config &child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
tchatbox_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg), grid()
{
state.push_back(tstate_definition(cfg.child("background")));
state.push_back(tstate_definition(cfg.child("foreground")));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = std::make_shared<tbuilder_grid>(child);
}
tunit_preview_pane_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg), grid()
{
state.push_back(tstate_definition(cfg.child("background")));
state.push_back(tstate_definition(cfg.child("foreground")));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_scrollbar_panel
*
* == Scrollbar panel ==
*
* @begin{parent}{name="gui/"}
* @begin{tag}{name="scrollbar_panel_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="gui/window_definition/resolution"}
* The definition of a panel with scrollbars. A panel is a container holding
* other elements in its grid. A panel is always enabled and can't be
* disabled. Instead it uses the states as layers to draw on.
*
* @begin{table}{config}
* grid & grid & & A grid containing the widgets for main
* widget. $
* @end{table}
* The following layers exist:
* * background, the background of the panel.
* * foreground, the foreground of the panel.
*
* @end{tag}{name="resolution"}
* @end{tag}{name="scrollbar_panel_definition"}
* @end{parent}{name="gui/"}
*/
tscrollbar_panel_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg), grid()
{
// The panel needs to know the order.
state.push_back(tstate_definition(cfg.child("background")));
state.push_back(tstate_definition(cfg.child("foreground")));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = std::make_shared<tbuilder_grid>(child);
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_scroll_label
*
* == Scroll label ==
*
* @macro = scroll_label_description
*
* @begin{parent}{name="gui/"}
* This widget is slower as a normal label widget so only use this widget
* when the scrollbar is required (or expected to become required).
* @begin{tag}{name="scroll_label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{table}{config}
* grid & grid & & A grid containing the widgets for main
* widget. $
* @end{table}
* @allow{link}{name="gui/window/resolution/grid"}
* TODO we need one definition for a vertical scrollbar since this is the second
* time we use it.
*
* @begin{table}{dialog_widgets}
* _content_grid & & grid & m & A grid which should only contain one
* label widget. $
* _scrollbar_grid & & grid & m & A grid for the scrollbar
* (Merge with listbox info.) $
* @end{table}
* @begin{tag}{name="content_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="content_grid"}
* @begin{tag}{name="scrollbar_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="scrollbar_grid"}
* The following states exist:
* * state_enabled, the scroll label is enabled.
* * state_disabled, the scroll label is disabled.
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="scroll_label_definition"}
* @end{parent}{name="gui/"}
*/
tscroll_label_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg), grid(NULL)
{
// Note the order should be the same as the enum tstate is scroll_label.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_scroll_label
*
* == Scroll label ==
*
* @macro = scroll_label_description
*
* @begin{parent}{name="gui/"}
* This widget is slower as a normal label widget so only use this widget
* when the scrollbar is required (or expected to become required).
* @begin{tag}{name="scroll_label_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{table}{config}
* grid & grid & & A grid containing the widgets for main
* widget. $
* @end{table}
* @allow{link}{name="gui/window/resolution/grid"}
* TODO we need one definition for a vertical scrollbar since this is the second
* time we use it.
*
* @begin{table}{dialog_widgets}
* _content_grid & & grid & m & A grid which should only contain one
* label widget. $
* _scrollbar_grid & & grid & m & A grid for the scrollbar
* (Merge with listbox info.) $
* @end{table}
* @begin{tag}{name="content_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="content_grid"}
* @begin{tag}{name="scrollbar_grid"}{min=0}{max=1}{super="gui/window/resolution/grid"}
* @end{tag}{name="scrollbar_grid"}
* The following states exist:
* * state_enabled, the scroll label is enabled.
* * state_disabled, the scroll label is disabled.
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @end{tag}{name="resolution"}
* @end{tag}{name="scroll_label_definition"}
* @end{parent}{name="gui/"}
*/
scroll_label_definition::resolution::resolution(const config& cfg)
: resolution_definition(cfg), grid(nullptr)
{
// Note the order should be the same as the enum state_t is scroll_label.hpp.
state.emplace_back(cfg.child("state_enabled"));
state.emplace_back(cfg.child("state_disabled"));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = std::make_shared<builder_grid>(child);
}
aspect_attacks::aspect_attacks(readonly_context &context, const config &cfg, const std::string &id)
: typesafe_aspect<attacks_vector>(context,cfg,id)
, filter_own_()
, filter_enemy_()
{
if (const config &filter_own = cfg.child("filter_own")) {
filter_own_ = filter_own;
}
if (const config &filter_enemy = cfg.child("filter_enemy")) {
filter_enemy_ = filter_enemy;
}
}
void tlobby_main::process_network_data(const config& data)
{
if(const config& error = data.child("error")) {
throw wesnothd_error(error["message"]);
} else if(data.child("gamelist")) {
process_gamelist(data);
} else if(const config& gamelist_diff = data.child("gamelist_diff")) {
process_gamelist_diff(gamelist_diff);
}
chatbox_->process_network_data(data);
}
tbuilder_listbox::tbuilder_listbox(const config& cfg)
: tbuilder_control(cfg)
, vertical_scrollbar_mode(
get_scrollbar_mode(cfg["vertical_scrollbar_mode"]))
, horizontal_scrollbar_mode(
get_scrollbar_mode(cfg["horizontal_scrollbar_mode"]))
, header(nullptr)
, footer(nullptr)
, list_builder(nullptr)
, list_data()
, has_minimum_(cfg["has_minimum"].to_bool(true))
, has_maximum_(cfg["has_maximum"].to_bool(true))
{
if(const config& h = cfg.child("header")) {
header = std::make_shared<tbuilder_grid>(h);
}
if(const config& f = cfg.child("footer")) {
footer = std::make_shared<tbuilder_grid>(f);
}
const config& l = cfg.child("list_definition");
VALIDATE(l, _("No list defined."));
list_builder = std::make_shared<tbuilder_grid>(l);
assert(list_builder);
VALIDATE(list_builder->rows == 1,
_("A 'list_definition' should contain one row."));
const config& data = cfg.child("list_data");
if(!data) {
return;
}
for(const auto & row : data.child_range("row"))
{
unsigned col = 0;
for(const auto & c : row.child_range("column"))
{
list_data.push_back(string_map());
for(const auto & i : c.attribute_range())
{
list_data.back()[i.first] = i.second;
}
++col;
}
VALIDATE(col == list_builder->cols,
_("'list_data' must have the same number of "
"columns as the 'list_definition'."));
}
}
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_horizonal_listbox
*
* == Horizontal listbox ==
* @begin{parent}{name="gui/"}
* @begin{tag}{name="horizontal_listbox_definition"}{min=0}{max=-1}{super="gui/listbox_definition"}
* @end{tag}{name="horizontal_listbox_definition"}
* @end{parent}{name="gui/"}
* @macro = horizontal_listbox_description
* The definition of a horizontal listbox is the same as for a normal listbox.
*/
tlistbox_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg), grid(nullptr)
{
// Note the order should be the same as the enum tstate in listbox.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
const config& child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = std::make_shared<tbuilder_grid>(child);
}
void loadgame::copy_era(config &cfg)
{
const config &replay_start = cfg.child("replay_start");
if (!replay_start) return;
const config &era = replay_start.child("era");
if (!era) return;
config &snapshot = cfg.child("snapshot");
if (!snapshot) return;
snapshot.add_child("era", era);
}
tscroll_text_box_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
, grid(NULL)
, text_x_offset(cfg["text_x_offset"])
, text_y_offset(cfg["text_y_offset"])
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_text_box
*
* == Text box ==
*
* The definition of a text box.
*
* @begin{parent}{name="gui/"}
* @begin{tag}{name="text_box_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* The resolution for a text box also contains the following keys:
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super=generic/widget_definition/resolution}
* @begin{table}{config}
* text_x_offset & f_unsigned & "" & The x offset of the text in the text
* box. This is needed for the code to
* determine where in the text the mouse
* clicks, so it can set the cursor
* properly. $
* text_y_offset & f_unsigned & "" & The y offset of the text in the text
* box. $
* @end{table}
*
* The following states exist:
* * state_enabled, the text box is enabled.
* * state_disabled, the text box is disabled.
* * state_focussed, the text box has the focus of the keyboard.
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @begin{tag}{name="state_focussed"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focussed"}
* @end{tag}{name="resolution"}
* @end{tag}{name="text_box_definition"}
* @end{parent}{name="gui/"}
*/
// Note the order should be the same as the enum tstate in text_box.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
const config &child = cfg.child("grid");
VALIDATE(child, _("No grid defined."));
grid = new tbuilder_grid(child);
}
game_config_manager()
: cfg_()
, paths_manager_()
, hotkey_manager_()
, font_manager_()
{
#ifdef _WIN32
std::setlocale(LC_ALL, "English");
#else
std::setlocale(LC_ALL, "C");
std::setlocale(LC_MESSAGES, "");
#endif
const std::string& intl_dir = get_intl_dir();
bindtextdomain ("wesnoth", intl_dir.c_str());
bind_textdomain_codeset ("wesnoth", "UTF-8");
bindtextdomain ("wesnoth-lib", intl_dir.c_str());
bind_textdomain_codeset ("wesnoth-lib", "UTF-8");
textdomain ("wesnoth");
font::load_font_config();
gui2::init();
load_language_list();
game_config::config_cache::instance().add_define("TEST");
game_config::config_cache::instance().get_config(game_config::path + "/data/test/", cfg_);
::init_textdomains(cfg_);
const std::vector<language_def>& languages = get_languages();
std::vector<language_def>::const_iterator English = std::find_if(languages.begin(),
languages.end(),
match_english); // Using German because the most active translation
::set_language(*English);
cfg_.merge_children("units");
const config* const units = cfg_.child("units");
if(units != NULL) {
unit_type_data::types().set_config(*units);
}
game_config::load_config(cfg_.child("game_config"));
hotkey::deactivate_all_scopes();
hotkey::set_scope_active(hotkey::SCOPE_GENERAL);
hotkey::set_scope_active(hotkey::SCOPE_GAME);
hotkey::load_hotkeys(cfg_);
paths_manager_.set_paths(cfg_);
font::load_font_config();
}
ttoggle_button_definition::tresolution::tresolution(const config& cfg)
: tresolution_definition_(cfg)
{
/*WIKI
* @page = GUIWidgetDefinitionWML
* @order = 1_toggle_button
*
* == Toggle button ==
*
* The definition of a toggle button.
*
* The following states exist:
* * state_enabled, the button is enabled and not selected.
* * state_disabled, the button is disabled and not selected.
* * state_focussed, the mouse is over the button and not selected.
*
* * state_enabled_selected, the button is enabled and selected.
* * state_disabled_selected, the button is disabled and selected.
* * state_focussed_selected, the mouse is over the button and selected.
* @begin{parent}{name="gui/"}
* @begin{tag}{name="toggle_button_definition"}{min=0}{max=-1}{super="generic/widget_definition"}
* @begin{tag}{name="resolution"}{min=0}{max=-1}{super="generic/widget_definition/resolution"}
* @begin{tag}{name="state_enabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled"}
* @begin{tag}{name="state_disabled"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled"}
* @begin{tag}{name="state_focussed"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focussed"}
* @begin{tag}{name="state_enabled_selected"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_enabled_selected"}
* @begin{tag}{name="state_disabled_selected"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_disabled_selected"}
* @begin{tag}{name="state_focussed_selected"}{min=0}{max=1}{super="generic/state"}
* @end{tag}{name="state_focussed_selected"}
* @end{tag}{name="resolution"}
* @end{tag}{name="toggle_button_definition"}
* @end{parent}{name="gui/"}
*/
// Note the order should be the same as the enum tstate in
// toggle_button.hpp.
state.push_back(tstate_definition(cfg.child("state_enabled")));
state.push_back(tstate_definition(cfg.child("state_disabled")));
state.push_back(tstate_definition(cfg.child("state_focussed")));
state.push_back(tstate_definition(cfg.child("state_enabled_selected")));
state.push_back(tstate_definition(cfg.child("state_disabled_selected")));
state.push_back(tstate_definition(cfg.child("state_focussed_selected")));
}
turn_info::PROCESS_DATA_RESULT turn_info::process_network_data(const config& cfg,
network::connection from, std::deque<config>& backlog, bool skip_replay)
{
if (const config &rnd_seed = cfg.child("random_seed")) {
rand_rng::set_seed(rnd_seed["seed"]);
//may call a callback function, see rand_rng::set_seed_callback
}
if (const config &msg = cfg.child("message"))
{
resources::screen->add_chat_message(time(NULL), msg["sender"], msg["side"],
msg["message"], events::chat_handler::MESSAGE_PUBLIC,
preferences::message_bell());
}
if (const config &msg = cfg.child("whisper") /*&& is_observer()*/)
{
resources::screen->add_chat_message(time(NULL), "whisper: " + msg["sender"].str(), 0,
msg["message"], events::chat_handler::MESSAGE_PRIVATE,
preferences::message_bell());
}
BOOST_FOREACH(const config &ob, cfg.child_range("observer")) {
resources::screen->add_observer(ob["name"]);
}
BOOST_FOREACH(const config &ob, cfg.child_range("observer_quit")) {
resources::screen->remove_observer(ob["name"]);
}
if (cfg.child("leave_game")) {
throw network::error("");
}
bool turn_end = false;
config::const_child_itors turns = cfg.child_range("turn");
if (turns.first != turns.second && from != network::null_connection) {
//forward the data to other peers
network::send_data_all_except(cfg, from);
}
const config& change = cfg.child_or_empty("change_controller");
const std::string& side_drop = cfg["side_drop"].str();
BOOST_FOREACH(const config &t, turns)
{
handle_turn(turn_end, t, skip_replay, backlog);
}