| C_rect | |
| Cunit_type::ability_metadata | |
| Cabout::credits_group::about_group | |
| ►Cabstract_validator | Used in parsing config file |
| ►Cschema_validation::schema_validator | Realization of serialization/validator.hpp abstract validator |
| Cschema_validation::schema_self_validator | |
| Cachievement | Represents a single achievement and its data |
| Cachievement_group | A set of achievements tied to a particular content |
| Cachievements | This class is responsible for reading all available achievements from mainline's and any add-ons' achievements.cfg files for use in achievements_dialog |
| Cpreferences::acquaintance | |
| ►Cai::action_result | |
| Cai::attack_result | |
| Cai::move_result | |
| Cai::recall_result | |
| Cai::recruit_result | |
| Cai::stopunit_result | |
| Cai::synced_command_result | |
| Cai::actions | |
| Cmp_game_settings::addon_content | |
| Caddon_info | |
| Caddon_info_translation | |
| Cgui2::dialogs::addon_manager::addon_order | |
| Caddon_tracking_info | Stores additional status information about add-ons |
| Cmp_game_settings::addon_version_info | |
| Caddons_client | Add-ons (campaignd) client class |
| Cadvance_unit_params | Advances the unit at loc if it has enough experience, maximum 20 times |
| Cpreferences::advanced_manager | |
| Cai::ai_target_defines | |
| Cai_testing | |
| Cconfig::all_children_iterator | |
| Cvconfig::all_children_iterator | |
| Cunit_animator::anim_elem | |
| Canimated< T > | |
| Canimated< image::locator > | |
| ►Canimated< unit_frame > | |
| Cunit_animation::particle | |
| Canimation_branch | |
| Canimation_cursor | |
| Cdisplay::announce_options | Holds options for calls to function 'announce' (announce) |
| Cconfig::any_child | |
| Ctod_manager::area_time_of_day | |
| Cplugins_context::aReg | |
| Carrow | Arrows destined to be drawn on the map |
| Cconfig::all_children_iterator::arrow_helper | |
| Cconfig::const_all_children_iterator::arrow_helper | |
| Cai::aspect_attacks_lua_filter | |
| ►Cai::aspect_factory | |
| Cai::register_aspect_factory< ASPECT > | |
| Cfilesystem::atomic_commit | Wrapper class that guarantees that file commit atomicity |
| Cattack_ref | |
| Cai::default_recruitment::attack_simulation | For Combat Analysis |
| Csimple_wml::node::attribute | |
| Cconfig::attribute_iterator | |
| Cvconfig::attribute_iterator | |
| Cstoryscreen::background_layer | |
| Cuser_handler::ban_info | Ban status description |
| Cwesnothd::ban_manager | |
| Cwesnothd::banned | |
| Cwesnothd::banned_compare | We want to move the lowest value to the top |
| Cwesnothd::banned_compare_subnet | |
| ►Cwfl::base_breakpoint | |
| Cwfl::end_breakpoint | |
| Cwfl::next_breakpoint | |
| Cwfl::step_in_breakpoint | |
| Cwfl::step_out_breakpoint | |
| ►Cwfl::base_candidate_action | |
| ►Cwfl::candidate_action_with_filters | |
| Cwfl::attack_candidate_action | |
| Cwfl::move_candidate_action | |
| Cpreferences::base_manager | |
| ►Cai::base_property_handler | |
| Cai::aspect_property_handler< T > | |
| ►Cai::vector_property_handler< T > | |
| Cai::facets_property_handler< T > | |
| Cbattle_context | Computes the statistics of a battle between an attacker and a defender unit |
| Cbattle_context_unit_stats | Structure describing the statistics of a unit involved in the battle |
| CBF_ctx | |
| Cfilesystem::binary_paths_manager | The paths manager is responsible for recording the various paths that binary files may be located at |
| Ccampaignd::blacklist | Add-on blacklist table |
| Cfilesystem::blacklist_pattern_list | |
| Cblindfold | |
| Cgui2::dialogs::bookmark_create | |
| Cdesktop::bookmark_info | |
| Ctheme::border_t | |
| Ceditor::brush | Single brush – a set of relative locations around a "hotspot", and related info such as the icon image |
| Cbuffered_istream | Helper class for buffering a std::istream |
| ►Cgui2::builder_widget | Contains the info needed to instantiate a widget |
| Cgui2::builder_grid | |
| Cgui2::implementation::builder_instance | |
| Cgui2::implementation::builder_pane | |
| ►Cgui2::implementation::builder_styled_widget | |
| Cgui2::implementation::builder_addon_list | |
| Cgui2::implementation::builder_button | |
| Cgui2::implementation::builder_chatbox | |
| Cgui2::implementation::builder_drawing | |
| Cgui2::implementation::builder_grid_listbox | A grid listbox is a styled_widget that holds several items of the same type |
| Cgui2::implementation::builder_horizontal_listbox | A horizontal listbox is a control that holds several items of the same type |
| Cgui2::implementation::builder_horizontal_scrollbar | |
| Cgui2::implementation::builder_image | |
| Cgui2::implementation::builder_label | |
| Cgui2::implementation::builder_listbox | A listbox is a control that holds several items of the same type |
| Cgui2::implementation::builder_matrix | |
| Cgui2::implementation::builder_menu_button | |
| Cgui2::implementation::builder_minimap | |
| Cgui2::implementation::builder_multi_page | |
| Cgui2::implementation::builder_multiline_text | |
| Cgui2::implementation::builder_multimenu_button | |
| Cgui2::implementation::builder_panel | |
| Cgui2::implementation::builder_password_box | |
| Cgui2::implementation::builder_progress_bar | |
| Cgui2::implementation::builder_repeating_button | |
| Cgui2::implementation::builder_scroll_label | |
| Cgui2::implementation::builder_scroll_text | |
| Cgui2::implementation::builder_scrollbar_panel | |
| Cgui2::implementation::builder_size_lock | |
| Cgui2::implementation::builder_slider | |
| Cgui2::implementation::builder_spacer | |
| Cgui2::implementation::builder_spinner | |
| Cgui2::implementation::builder_stacked_widget | |
| Cgui2::implementation::builder_text_box | |
| Cgui2::implementation::builder_toggle_button | |
| Cgui2::implementation::builder_toggle_panel | |
| Cgui2::implementation::builder_tree_view | |
| Cgui2::implementation::builder_unit_preview_pane | |
| Cgui2::implementation::builder_vertical_scrollbar | |
| Cgui2::implementation::builder_window | |
| Cgui2::implementation::builder_viewport | |
| Cgui2::builder_window | |
| Cterrain_builder::building_rule | The in-memory representation of a [terrain_graphics] WML rule |
| Cgui2::dialogs::message::button_status | |
| Cwb::side_actions_container::by_hex | Tag for action_set's hashed_non_unique index |
| Cwb::side_actions_container::by_unit | Tag for action_set's hashed_non_unique index |
| Cimage::cache_type< T >::cache_item | |
| Cimage::cache_type< T > | |
| Cai::default_recruitment::cached_combat_value | |
| Cwfl::call_stack_manager | Provides debugging information for error messages |
| ►Cwfl::callable_die_subscriber | |
| Cwfl::variant_callable | |
| Ccampaign_controller | |
| Cstatistics_record::campaign_stats_t | |
| Ccampaign_type_defines | |
| Cdisplay_context::can_move_result | |
| ►Cai::candidate_action_factory | |
| Cai::register_candidate_action_factory< CANDIDATE_ACTION > | |
| Cgui2::canvas | A simple canvas which can be drawn upon |
| Ccarryover | |
| Ccarryover_info | |
| Cspirit_po::catalog< hashmap_type, pf_compiler > | |
| Cspirit_po::catalog_metadata | |
| Ccave_map_generator::cave_map_generator_job | |
| Ccfg_to_loc | |
| Ccave_map_generator::cave_map_generator_job::chamber | |
| ►Cevents::chat_handler | |
| Cevents::menu_handler | |
| Cgui2::chatbox | |
| Cdisplay_chat_manager::chat_message | |
| Cchat_msg | |
| Cchatroom_log | |
| ►Ccheckup | A class to check whether the results that were calculated in the replay match the results calculated during the original game |
| Cignored_checkup | |
| Cmp_debug_checkup | This checkup always compares the results in from different clients in a mp game but it also causes more network overhead |
| Csynced_checkup | This checkup compares whether the results calculated during the original game match the ones calculated during replay |
| Cgui2::generator< minimum_selection, maximum_selection, my_placement, select_action >::child | Definition of an item |
| Cgui2::grid::child | Child item of the grid |
| Cconfig::child_iterator | |
| Cconfig::child_pos | |
| Cwb::side_actions_container::chronological | Tag for action_set's random_access index |
| Csound::chunk_load_exception | |
| CCKey | Class that keeps track of all the keys on the keyboard |
| Cactions::clearer_info | Class that stores the part of a unit's data that is needed for fog clearing |
| ►Cgui2::clickable_item | Small concept class |
| Cgui2::button | Simple push button |
| Cgui2::repeating_button | A repeating_button is a control that can be pushed down and repeat a certain action |
| Cclip_rect_setter | |
| Cdraw::clip_setter | A class to manage automatic restoration of the clipping region |
| Cevents::cmd_arg_parser | |
| Ccolor_range | A color range definition is made of four reference RGB colors, used for calculating conversions from a source/key palette |
| Ccombatant | All combat-related info |
| Cgui2::dialogs::attack_predictions::combatant_data | |
| Cevents::map_command_handler< Worker >::command | |
| Cevents::command_disabler | |
| ►Chotkey::command_executor | |
| ►Chotkey::command_executor_default | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| ►Cplay_controller::hotkey_handler | |
| ►Cplaysingle_controller::hotkey_handler | |
| Cplaymp_controller::hotkey_handler | |
| Cai::command_history_item | AI Command History Item |
| Ccampaignd::command_line | |
| Clua_kernel_base::command_log | Log implementation |
| Ccommandline_options | |
| Ccompare_samples_by_time | |
| Ccompare_samples_to_stringspan | |
| Cspirit_po::default_plural_forms::compiler | |
| ►Cai::component | |
| Cai::ai_composite | |
| ►Cai::aspect | |
| ►Cai::typesafe_aspect< attacks_vector > | |
| ►Cai::ai_default_rca::aspect_attacks_base | |
| Cai::ai_default_rca::aspect_attacks | |
| Cai::aspect_attacks_lua | |
| ►Cai::typesafe_aspect< T > | |
| ►Cai::standard_aspect< config > | |
| Cai::default_recruitment::recruitment_aspect | |
| Cai::composite_aspect< T > | |
| Cai::lua_aspect< T > | |
| Cai::standard_aspect< T > | |
| ►Cai::candidate_action | |
| Cai::ai_default_rca::combat_phase | |
| Cai::ai_default_rca::get_healing_phase | |
| Cai::ai_default_rca::get_villages_phase | |
| Cai::ai_default_rca::goto_phase | |
| Cai::ai_default_rca::leader_control_phase | |
| Cai::ai_default_rca::leader_shares_keep_phase | |
| Cai::ai_default_rca::move_leader_to_goals_phase | |
| Cai::ai_default_rca::move_leader_to_keep_phase | |
| Cai::ai_default_rca::move_to_targets_phase | |
| Cai::ai_default_rca::retreat_phase | |
| Cai::default_recruitment::recruitment | |
| Cai::fai_candidate_action_wrapper | |
| ►Cai::lua_candidate_action_wrapper_base | |
| ►Cai::lua_candidate_action_wrapper | |
| Cai::lua_sticky_candidate_action_wrapper | |
| Cai::lua_candidate_action_wrapper_external | |
| Cai::default_recruitment::recruit_job | |
| Cai::default_recruitment::recruit_limit | |
| ►Cai::engine | |
| Cai::engine_cpp | |
| Cai::engine_fai | |
| Cai::engine_lua | |
| ►Cai::goal | |
| Cai::lua_goal | |
| ►Cai::protect_goal | |
| Cai::protect_location_goal | |
| Cai::protect_unit_goal | |
| Cai::target_location_goal | |
| Cai::target_unit_goal | |
| ►Cai::stage | |
| Cai::ai_default_rca::candidate_action_evaluation_loop | |
| Cai::idle_stage | |
| Cai::lua_stage_wrapper | |
| Cai::stage_side_formulas | |
| Cai::stage_unit_formulas | |
| Ccomponent_availability_defines | |
| Cai::component_manager | |
| Cunit_filter_impl::conditional_type_defines | |
| Cconfig | A config object defines a single node in a WML file, with access to child nodes |
| Cconfig_attribute_value | Variant for storing WML attributes |
| ►Cgame_config::config_cache | Singleton class to manage game config file caching |
| Ctest_config_cache | Used to make distinct singleton for testing it because other tests will need original one to load data |
| Cconfig_cache_fixture | |
| Cgame_config::config_cache_transaction | Used to share macros between cache objects You have to create transaction object to load all macros to memory and share them subsequent cache loads |
| Cdetail::config_construct_unpacker< T > | |
| Cdetail::config_construct_unpacker< K, V, Rest... > | |
| Cdetail::config_construct_unpacker< T, config &, Rest... > | |
| Cdetail::config_construct_unpacker< T, config, Rest... > | |
| Cdetail::config_construct_unpacker<> | |
| Cai::config_value_translator< T > | |
| Cai::config_value_translator< bool > | |
| Cai::config_value_translator< config > | |
| Cai::config_value_translator< std::string > | |
| Cai::config_value_translator< std::vector< std::string > > | |
| Cai::config_value_translator< terrain_filter > | |
| Cai::config_value_translator< unit_advancements_aspect > | |
| Cai::config_value_translator< utils::variant< bool, std::vector< std::string > > > | |
| Cconfig_writer | Class for writing a config out to a file in pieces |
| Cconfigr_of | |
| Cai::configuration | |
| Cng::configure_engine | Configure_engine |
| ►Cng::connect_engine | |
| Ctest_connect_engine | |
| Cnetwork_asio::connection | A class that represents a TCP/IP connection |
| Cgui2::dialogs::network_transmission::connection_data | A wrapper of either a wesnothd_connection or a network_asio::connection |
| ►Cnetwork_transmission::connection_data | |
| Cconnect_connection_data | |
| Cread_addon_connection_data | |
| Cwrite_addon_connection_data | |
| Cwesnothd::server::connection_log | |
| Cconfig::const_all_children_iterator | |
| Cconfig::const_attribute_iterator | |
| Cconfig::const_child_iterator | |
| Cutils::const_clone< D, S > | Helper struct to clone the constness of one type to another |
| ►Cutils::const_clone< T, V > | |
| Cvariable_info_implementation::maybe_const< T, V > | |
| Cunit_map::const_iter_types | |
| Cspirit_po::default_plural_forms::constant | |
| Cutils::detail::contains_impl< Container, Value > | A struct that exists to implement a generic wrapper for std::find |
| Cutils::detail::contains_impl< Container, typename Container::key_type > | A struct that exists to implement a generic wrapper for the find() member of associative containers |
| Cevents::context | |
| Creports::context | |
| Ccampaignd::control_line | Represents a server control line written to a communication socket |
| Cgui2::dialogs::chat_log::controller | |
| Cgui2::dialogs::gamestate_inspector::controller | |
| Cgui2::dialogs::lua_interpreter::controller | The controller is responsible to hold all the input widgets, and a pointer to the model and view |
| Cucs4_convert_impl::convert_impl< T_CHAR > | |
| Cucs4_convert_impl::convert_impl< char > | |
| Cucs4_convert_impl::convert_impl< char16_t > | |
| Cucs4_convert_impl::convert_impl< char32_t > | |
| Cucs4_convert_impl::convert_impl< wchar_t > | |
| ►Cpathfind::cost_calculator | |
| Cai::ai_default_rca::move_cost_calculator | |
| Clua_pathfind_cost_calculator | Cost function object relying on a Lua function |
| Cpassage_path_calculator | |
| Cpathfind::dummy_path_calculator | Function which doesn't take anything into account |
| Cpathfind::emergency_path_calculator | Function which only uses terrain, ignoring shroud, enemies, etc |
| Cpathfind::move_type_path_calculator | |
| Cpathfind::shortest_path_calculator | |
| Cschema_validation::schema_validator::counter | |
| Cng::create_engine | |
| Csavegame::create_save_info | |
| Cabout::credits_group | |
| Cai::default_recruitment::data | |
| Cmovetype::terrain_info::data | |
| Ctournaments::data | |
| Cdbconn | This class is responsible for handling the database connections as well as executing queries and handling any results |
| Cwfl::debug_info | |
| Cdefault_map_generator_job | |
| Cunit_type::defaut_ctor_t | |
| Cdefeat_condition_defines | |
| Cai::defensive_position | |
| ►CDefinition | |
| Cstring_enums::enum_base< Definition > | The base template for associating string values with enum values |
| Cai::ai_default_rca::desc_sorter_of_candidate_actions | |
| Cai::description | AI parameters |
| ►Cboost::dfs_visitor | |
| Cutils::back_edge_detector< Callback > | A helper for boost::depth_first_search (DFS) usage with the purpose of detecting cycles |
| Cgui::dialog_frame::dimension_measurements | |
| ►Cgui2::event::dispatcher | Base class for event handling |
| ►Cgui2::widget | Base class for all widgets |
| ►Cgui2::generator_base | Abstract base class for the generator |
| Cgui2::policy::maximum_selection::many_items | No maximum amount of items to select |
| Cgui2::policy::maximum_selection::one_item | May select only one item |
| Cgui2::policy::minimum_selection::no_item | No minimum selection |
| Cgui2::policy::minimum_selection::one_item | Must select at least one item |
| Cgui2::policy::placement::horizontal_list | Places the items in a horizontal row |
| Cgui2::policy::placement::independent | Places the items independent of each other |
| Cgui2::policy::placement::table | Places the items in a grid |
| Cgui2::policy::placement::vertical_list | Places the items in a vertical column |
| Cgui2::policy::select_action::selection | Select the item, this requires the grid to contain a selectable_item |
| Cgui2::policy::select_action::show | Show the item |
| Cgui2::grid | Base container class |
| Cgui2::pane | A pane is a container where new members can be added and removed during run-time |
| ►Cgui2::styled_widget | Base class for all visible items |
| Cgui2::button | Simple push button |
| ►Cgui2::container_base | A generic container base class |
| Cgui2::addon_list | |
| Cgui2::chatbox | |
| Cgui2::multi_page | A multi page is a control that contains several 'pages' of which only one is visible |
| ►Cgui2::panel | A panel is a visible container to hold multiple widgets |
| Cgui2::toggle_panel | Class for a toggle button |
| ►Cgui2::window | Base class of top level items, the only item which needs to store the final canvases to draw on |
| ►Cgui2::dialogs::modal_dialog | Abstract base class for all modal dialogs |
| Cgui2::dialogs::achievements_dialog | This shows a dialog displaying achievements |
| Cgui2::dialogs::addon_auth | This shows the dialog to provide a password when uploading an add-on |
| Cgui2::dialogs::addon_connect | This shows the dialog for managing addons and connecting to the addon server |
| Cgui2::dialogs::addon_license_prompt | |
| Cgui2::dialogs::addon_manager | Shows the list of addons on the server available for installation |
| Cgui2::dialogs::addon_uninstall_list | Dialog with a checkbox list for choosing installed add-ons to remove |
| Cgui2::dialogs::attack_predictions | |
| Cgui2::dialogs::campaign_difficulty | The campaign mode difficulty menu |
| Cgui2::dialogs::campaign_selection | This shows the dialog which allows the user to choose which campaign to play |
| Cgui2::dialogs::chat_log | |
| Cgui2::dialogs::community_dialog | This shows a dialog displaying community links |
| Cgui2::dialogs::core_selection | This shows the dialog which allows the user to choose which core to play |
| Cgui2::dialogs::custom_tod | This shows the dialog to modify tod schedules |
| Cgui2::dialogs::depcheck_confirm_change | Asks the user to confirm a change required to proceed |
| Cgui2::dialogs::depcheck_select_new | Offers a list of compatible items if a currently selected one is incompatible |
| Cgui2::dialogs::drop_down_menu | Used by the menu_button widget |
| Cgui2::dialogs::edit_label | Dialog for editing gamemap labels |
| Cgui2::dialogs::edit_text | Dialog for renaming units in-game |
| Cgui2::dialogs::editor_choose_addon | Dialog for adding a translation while editing an add-on's _server.pbl |
| Cgui2::dialogs::editor_edit_label | Dialog for editing gamemap labels |
| Cgui2::dialogs::editor_edit_pbl | Dialog for editing an add-on's _server.pbl |
| Cgui2::dialogs::editor_edit_pbl_translation | Dialog for adding a translation while editing an add-on's _server.pbl |
| Cgui2::dialogs::editor_edit_scenario | Dialog for editing gamemap scenarios |
| Cgui2::dialogs::editor_edit_side | Dialog for editing gamemap sides |
| Cgui2::dialogs::editor_edit_unit | Dialog that allows user to create custom unit types |
| Cgui2::dialogs::editor_generate_map | The dialog for selecting which random generator to use in the editor |
| Cgui2::dialogs::editor_new_map | |
| Cgui2::dialogs::editor_resize_map | This shows the dialog to resize the current map |
| Cgui2::dialogs::end_credits | |
| Cgui2::dialogs::faction_select | |
| Cgui2::dialogs::file_dialog | |
| Cgui2::dialogs::folder_create | Dialog for providing the name of a new folder to create |
| Cgui2::dialogs::formula_debugger | This shows the debugger for the formulas |
| Cgui2::dialogs::game_cache_options | A Preferences subdialog including a report on the location and size of the game's WML cache, buttons to copy its path to clipboard or browse to it, and the possibility of clearing stale files from the cache or purging it entirely |
| Cgui2::dialogs::game_delete | This shows the dialog to confirm deleting a savegame file |
| Cgui2::dialogs::game_load | This shows the dialog to select and load a savegame file |
| Cgui2::dialogs::game_save | This shows the dialog to create a savegame file |
| Cgui2::dialogs::game_save_message | |
| Cgui2::dialogs::game_save_oos | |
| Cgui2::dialogs::game_stats | |
| Cgui2::dialogs::game_version | Dialog displaying the various paths used by the game to locate resource and configuration files |
| Cgui2::dialogs::gamestate_inspector | This shows the gamestate inspector |
| Cgui2::dialogs::generator_settings | |
| Cgui2::dialogs::help_browser | Help browser dialog |
| Cgui2::dialogs::hotkey_bind | |
| Cgui2::dialogs::install_dependencies | |
| Cgui2::dialogs::label_settings | |
| Cgui2::dialogs::language_selection | This shows the dialog to select the language to use |
| Cgui2::dialogs::loading_screen | |
| Cgui2::dialogs::lobby_player_info | |
| Cgui2::dialogs::log_settings | |
| Cgui2::dialogs::lua_interpreter | |
| Cgui2::dialogs::message | Main class to show messages to the user |
| Cgui2::dialogs::migrate_version_selection | This shows the dialog to select a previous version of Wesnoth to migrate preferences from and redownload add-ons |
| Cgui2::dialogs::mp_alerts_options | A Preferences subdialog permitting to configure the sounds and notifications generated in response to various mp lobby / game events |
| Cgui2::dialogs::mp_change_control | This shows the multiplayer change control dialog |
| Cgui2::dialogs::mp_connect | This shows the dialog to the MP server to connect to |
| Cgui2::dialogs::mp_create_game | |
| Cgui2::dialogs::mp_host_game_prompt | This shows the dialog to confirm deleting a savegame file |
| Cgui2::dialogs::mp_join_game | |
| Cgui2::dialogs::mp_join_game_password_prompt | Dialog for entering a password for joining a password-protected MP game |
| Cgui2::dialogs::mp_lobby | |
| Cgui2::dialogs::mp_login | This shows the dialog to log in to the MP server |
| Cgui2::dialogs::mp_match_history | |
| Cgui2::dialogs::mp_method_selection | This shows the dialog to select the kind of MP game the user wants to play |
| Cgui2::dialogs::mp_report | This shows a dialog to report players on the multiplayer server |
| Cgui2::dialogs::mp_staging | |
| Cgui2::dialogs::network_transmission | Dialog that tracks network transmissions |
| Cgui2::dialogs::outro | Dialog to display 'The End' at the end of a campaign |
| Cgui2::dialogs::preferences_dialog | |
| Cgui2::dialogs::prompt | Dialog for getting a single text value from the player |
| Cgui2::dialogs::screenshot_notification | Notification dialog used after saving a game or map screenshot to display information about it for the user |
| Cgui2::dialogs::select_orb_colors | |
| Cgui2::dialogs::server_info | |
| Cgui2::dialogs::simple_item_selector | A simple one-column listbox with OK and Cancel buttons |
| Cgui2::dialogs::sp_options_configure | |
| Cgui2::dialogs::statistics_dialog | |
| Cgui2::dialogs::story_viewer | Dialog to view the storyscreen |
| Cgui2::dialogs::surrender_quit | This shows the dialog to confirm surrender and/or quitting the game |
| Cgui2::dialogs::synched_choice_wait | |
| Cgui2::dialogs::terrain_layers | |
| Cgui2::dialogs::theme_list | Dialog for selecting a GUI theme |
| Cgui2::dialogs::title_screen | This class implements the title screen |
| Cgui2::dialogs::tod_new_schedule | Dialog that takes new schedule ID and name from the player |
| Cgui2::dialogs::transient_message | Shows a transient message |
| Cgui2::dialogs::unit_advance | |
| Cgui2::dialogs::unit_attack | This shows the dialog for attacking units |
| Cgui2::dialogs::unit_create | This shows the debug-mode dialog to create new units on the map |
| Cgui2::dialogs::unit_list | |
| Cgui2::dialogs::unit_recall | |
| Cgui2::dialogs::unit_recruit | |
| Cgui2::dialogs::wml_error | WML preprocessor/parser error report dialog |
| ►Cgui2::dialogs::wml_message_base | Base class for the wml generated messages |
| ►Cgui2::dialogs::wml_message_left | Shows a dialog with the portrait on the left side |
| Cgui2::dialogs::wml_message_double | Shows a dialog with two portraits, one on each side |
| Cgui2::dialogs::wml_message_right | Shows a dialog with the portrait on the right side |
| ►Cgui2::dialogs::modeless_dialog | The popup class shows windows that are shown non-modal |
| Cgui2::dialogs::debug_clock | Clock to test the draw events |
| Cgui2::dialogs::file_progress | |
| Cgui2::dialogs::tooltip | Class to show the tips |
| ►Cgui2::scrollbar_container | Base class for creating containers with one or two scrollbar(s) |
| Cgui2::listbox | The listbox class |
| Cgui2::scroll_label | Label showing a text |
| Cgui2::scroll_text | Scrollable text area |
| Cgui2::scrollbar_panel | Visible container to hold multiple widgets |
| Cgui2::tree_view | A tree view is a control that holds several items of the same or different types |
| Cgui2::size_lock | A fixed-size widget that wraps an arbitrary widget and forces it to the given size |
| Cgui2::spinner | Spinner widget |
| Cgui2::stacked_widget | A stacked widget holds several widgets on top of each other |
| Cgui2::unit_preview_pane | |
| ►Cgui2::control_NEW< STATE > | |
| Cgui2::matrix | List with the matrix specific variables: |
| Cgui2::drawing | A drawing is widget with a fixed size and gives access to the canvas of the widget in the window instance |
| Cgui2::image | An image shows a static image |
| Cgui2::label | A label displays text that can be wrapped but no scrollbars are provided |
| Cgui2::menu_button | A menu_button is a styled_widget to choose an element from a list of elements |
| Cgui2::minimap | The basic minimap class |
| Cgui2::multimenu_button | A multimenu_button is a styled_widget to choose an element from a list of elements |
| Cgui2::progress_bar | This object shows the progress of a certain action, or the value state of a certain item |
| Cgui2::repeating_button | A repeating_button is a control that can be pushed down and repeat a certain action |
| ►Cgui2::scrollbar_base | Base class for a scroll bar |
| Cgui2::horizontal_scrollbar | A horizontal scrollbar is a widget that shows a horizontal scrollbar |
| Cgui2::vertical_scrollbar | The definition of a vertical scrollbar |
| ►Cgui2::slider_base | Base class for a scroll bar |
| Cgui2::slider | A slider is a control that can select a value by moving a grip on a groove |
| Cgui2::spacer | An empty widget to either fill in a widget since no empty items are allowed or to reserve a fixed space |
| ►Cgui2::text_box_base | Abstract base class for text items |
| Cgui2::multiline_text | Base class for a multiline text area |
| ►Cgui2::text_box | Class for a single line text area |
| Cgui2::password_box | |
| Cgui2::toggle_button | Class for a toggle button |
| Cgui2::tree_view_node | |
| Cgui2::viewport | A viewport is an special widget used to view only a part of the widget it 'holds' |
| Cgui2::event::dispatcher_implementation | |
| Cdisplay_chat_manager | |
| ►Cdisplay_context | Abstract class for exposing game data that doesn't depend on the GUI, however which for historical reasons is generally accessed via the GUI method display::get_singleton() |
| Ceditor::map_context | This class wraps around a map to provide a concise interface for the editor to work with |
| Cgame_board | Game board class |
| Cpathfind::ignore_units_display_context | |
| Csimple_wml::document | |
| Cdisplay::draw_helper | Helper for rendering the map by ordering draw operations |
| Csound::driver_status | |
| ►Ceditor::editor_action | Base class for all editor actions |
| Ceditor::editor_action_apply_mask | |
| Ceditor::editor_action_chain | Container action wrapping several actions into one |
| Ceditor::editor_action_create_mask | |
| ►Ceditor::editor_action_extendable | Base class for actions that: 1) operate on an area 2) can be used as undo for a click-drag operation 3) can be extended so one undo action undos several actual drag actions |
| ►Ceditor::editor_action_area | Base class for area-affecting actions |
| Ceditor::editor_action_deselect | Deselect the given locations |
| Ceditor::editor_action_paint_area | Paint the same terrain on a number of locations on the map |
| Ceditor::editor_action_select | Select the given locations |
| Ceditor::editor_action_shuffle_area | Randomize terrain in an area |
| Ceditor::editor_action_paste | Paste a map fragment into the map |
| ►Ceditor::editor_action_location | Base class for actions which act on a specified location (and possibly on other locations that can be derived from the staring hex) |
| Ceditor::editor_action_item | Place a new item on the map |
| Ceditor::editor_action_item_delete | Remove a item from the map |
| Ceditor::editor_action_item_facing | |
| Ceditor::editor_action_item_replace | |
| Ceditor::editor_action_label | Set label action |
| Ceditor::editor_action_label_delete | |
| ►Ceditor::editor_action_location_terrain | Base class for actions which in addition to acting on a hex, act with one terrain type, i.e |
| Ceditor::editor_action_fill | Flood fill |
| Ceditor::editor_action_starting_position | Set starting position action, sets location ids (both for starting locations and for non-starting locations) |
| Ceditor::editor_action_unit | Place a new unit on the map |
| Ceditor::editor_action_unit_delete | Remove a unit from the map |
| Ceditor::editor_action_unit_facing | |
| Ceditor::editor_action_unit_replace | |
| Ceditor::editor_action_village | Sets the ownership of a village to the current side |
| Ceditor::editor_action_village_delete | Clears the ownership of a village |
| Ceditor::editor_action_resize_map | Resize the map |
| Ceditor::editor_action_select_all | Select the entire map |
| Ceditor::editor_action_select_inverse | Invert the selection |
| Ceditor::editor_action_select_none | Clear selection |
| Ceditor::editor_action_whole_map | Replace contents of the entire map, Useful as a fallback undo method when something else would be impractical |
| Ceditor::editor_team_info | |
| Ceditor::editor_toolkit | |
| Chalo::halo_impl::effect | |
| Cunit_abilities::effect | |
| Cng::depcheck::manager::elem | Component (era, modification or scenario) |
| Cenable_lua_ptr< T > | |
| ►Cenable_lua_ptr< widget > | |
| Cgui2::widget | Base class for all widgets |
| ►Cstd::enable_shared_from_this | |
| Cattack_type | |
| Csavegame::save_index_class | |
| Cunit | This class represents a single unit of a specific type |
| ►Cwb::action | Abstract base class for all the whiteboard planned actions |
| Cdummy_action | |
| ►Cwb::move | A planned move, represented on the map by an arrow and a ghosted unit in the destination hex |
| Cwb::attack | |
| Cwb::recall | |
| Cwb::recruit | |
| Cwb::suppose_dead | A planned action that temporarily removes a unit from the map for planning purposes |
| Cwb::side_actions | This internal whiteboard class holds the planned action queues for a team, and offers many utility methods to create and manipulate them |
| Cucs4_convert_impl::enableif< Tret, Tcheck > | |
| Cend_level_data | Additional information on the game outcome which can be provided by WML |
| ►Cai::engine_factory | |
| Cai::register_engine_factory< ENGINE > | |
| Cgui2::dialogs::drop_down_menu::entry_data | |
| Cconfig_attribute_value::equality_visitor | Visitor handling equality checks |
| ►Cboost::program_options::error | |
| Cbad_commandline_resolution | |
| Cbad_commandline_tuple | |
| Cplugins_manager::event | |
| Cevents::event_context | |
| ►Cgui2::event_executor | Event execution calls |
| Cgui2::widget | Base class for all widgets |
| ►Cgame_events::event_filter | Represents a single filter condition on an event |
| Cgame_events::filter_attack | |
| Cgame_events::filter_condition | |
| Cgame_events::filter_dynamic | This is a dynamic wrapper for any filter type, specified via [insert_tag] |
| Cgame_events::filter_formula | |
| Cgame_events::filter_side | |
| Cgame_events::filter_unit | |
| Clua_event_filter | |
| Cgame_events::event_handler | |
| Cgame_events::event_handlers | |
| Csynced_context::event_info | |
| ►Cstd::exception | STL class |
| Caddons_client::invalid_server_address | |
| Caddons_client::not_connected_to_server | |
| Caddons_client::user_disconnect | |
| Caddons_client::user_exit | |
| Cbad_lexical_cast | Thrown when a lexical_cast fails |
| ►Cgame::error | Base class for all the errors encountered by the engine |
| Cabstract_validator::error | Used to manage with not initialized validators Supposed to be thrown from the constructor |
| ►Cconfig::error | |
| Cvconfig::recursion_error | |
| ►Ceditor::editor_exception | |
| Ceditor::editor_action_exception | |
| Ceditor::editor_logic_exception | |
| Ceditor::editor_map_integrity_error | |
| Ceditor::editor_map_load_exception | |
| Ceditor::editor_map_operation_exception | |
| Ceditor::editor_map_save_exception | |
| Cfilesystem::io_exception | An exception object used when an IO error occurs |
| Cfont::error | |
| ►Cgame::game_error | Error used for any general game error, e.g |
| Cunit_type_error | |
| Cgame::load_game_failed | Error used when game loading fails |
| Cgame::lua_error | Error used to report an error in a lua script or in the lua interpreter |
| Cgame::mp_server_error | |
| Cgame::save_game_failed | Error used when game saving fails |
| Cgui::button::error | |
| Cgui::tristate_button::error | |
| Chelp::parse_error | Thrown when the help system fails to parse something |
| Cincorrect_map_format_error | |
| Cmapgen_exception | |
| Cnetwork_asio::error | |
| Cpreproc_config::error | |
| Csdl::exception | |
| Cserver_shutdown | |
| Csimple_wml::error | |
| Ct_translation::error | |
| Cunit_filter_impl::filter_error | |
| Cuser_handler::error | |
| Cutils::hash_error | |
| Cvideo::error | An error specifically indicating video subsystem problems |
| Cwb::action::ctor_err | |
| Cwesnothd::banned::error | |
| ►Cwesnothd_error | An error occurred during when trying to communicate with the wesnothd server |
| Cingame_wesnothd_error | We received invalid data from wesnothd during a game This means we cannot continue with the game but we can stay connected to wesnothd and start a new game |
| Cleavegame_wesnothd_error | |
| Cwesnothd_connection_error | An error occurred inside the underlying network communication code (boost asio) TODO: find a short name |
| Cwesnothd_rejected_client_error | Error used when the client is rejected by the MP server |
| Cwfl::formula_error | |
| Cwfl::type_error | |
| ►Cgui2::layout_exception_resize_failed | Basic exception when the layout doesn't fit |
| Cgui2::layout_exception_height_resize_failed | Exception thrown when the height resizing has failed |
| Cgui2::layout_exception_width_resize_failed | Exception thrown when the width resizing has failed |
| Cgui2::layout_exception_width_modified | Exception thrown when the width has been modified during resizing |
| Cgui2::window_builder_invalid_id | Helper struct to signal that get_window_builder failed |
| Cinvalid_lua_argument | |
| Cinvalid_pbl_exception | Exception thrown when the WML parser fails to read a .pbl file |
| Cinvalid_variablename_exception | |
| Cname_generator_invalid_exception | |
| Cquit_game_exception | |
| Creset_gamestate_exception | |
| Creturn_to_play_side_exception | Exception used to escape form the ai or ui code to playsingle_controller::play_side |
| Csavegame::load_game_exception | Exception used to signal that the user has decided to abortt a game, and to load another game instead |
| ►Cstd::logic_error | STL class |
| Cgui2::iteration::logic_error | Thrown when deferring an invalid iterator |
| ►Cstd::runtime_error | STL class |
| Cspirit_po::catalog_exception | |
| ►Cstd::range_error | STL class |
| Cgui2::iteration::range_error | Thrown when moving an invalid iterator |
| Cutf8::invalid_utf8_exception | Thrown by operations encountering invalid UTF-8 data |
| Cgui2::executor | Helper to make removing a timer in a callback safe |
| Cng::create_engine::extras_metadata | |
| Cwfl::fai_variant_visitor | |
| Ctest_utils::fake_display_manager | |
| Cgame_config::fake_transaction | Holds a fake cache transaction if no real one is used |
| Cfake_unit_manager | Manages a list of fake units for the display object |
| Cfake_unit_ptr | Holds a temporary unit that can be drawn on the map without being placed in the unit_map |
| ►Cstd::false_type | |
| Clua_check_impl::is_container< T, T2 > | |
| Clua_check_impl::is_map< T, T2 > | |
| Clua_check_impl::is_pair< T, T2 > | |
| ►Cgui2::field_base | Abstract base class for the fields |
| ►Cgui2::field< bool, selectable_item > | |
| Cgui2::field_bool | Specialized field class for boolean |
| ►Cgui2::field< std::string, styled_widget, const std::string & > | |
| Cgui2::field_label | Specialized field class for a styled_widget, used for labels and images |
| ►Cgui2::field< std::string, text_box_base, const std::string & > | |
| Cgui2::field_text | Specialized field class for text |
| Cgui2::field< T, W, CT > | Template class to implement the generic field implementation |
| Cfilesystem::file_tree_checksum | |
| Clua_mapgen::filter | |
| ►Cfilter_context | |
| Ceditor::context_manager | |
| Cgame_state | |
| Cpathfind::ignore_units_filter_context | |
| ►Cfilter_impl | |
| Cterrain_filter | |
| Cng::flg_manager | FLG stands for faction, leader and gender |
| Cstoryscreen::floating_image | Represents and contains information about image labels used in story screen parts |
| Cfont::floating_label | |
| ►Cfont::floating_label_context | Structure which will hide all current floating labels, and cause floating labels instantiated after it is created to be displayed |
| Cgui::dialog_manager | |
| Cgui::floating_textbox | |
| Cformatter | Std::ostringstream wrapper |
| Cwfl::formula | |
| ►Cwfl::formula_callable | |
| Cai::formula_ai | |
| Cimage::pixel_callable | |
| Clua_callable | |
| Cmock_char | |
| Cmock_party | |
| ►Cwfl::action_callable | |
| Cai::attack_analysis | |
| Cwfl::attack_callable | |
| Cwfl::fallback_callable | |
| Cwfl::move_callable | |
| Cwfl::move_partial_callable | |
| Cwfl::recall_callable | |
| Cwfl::recruit_callable | |
| Cwfl::safe_call_callable | |
| Cwfl::set_unit_var_callable | |
| Cwfl::set_var_callable | |
| Cwfl::attack_map_callable | |
| Cwfl::attack_type_callable | |
| Cwfl::config_callable | |
| Cwfl::dot_callable | |
| Cwfl::event_callable | An object representing the state of the current event; equivalent to Lua's wesnoth.current.event_context |
| Cwfl::formula_callable_with_backup | |
| Cwfl::formula_variant_callable_with_backup | |
| Cwfl::gamemap_callable | |
| Cwfl::gamestate_callable | An object representing the state of the game, providing access to the map and basic information |
| Cwfl::key_value_pair | |
| Cwfl::list_callable | |
| Cwfl::location_callable | |
| Cwfl::map_callable | |
| Cwfl::map_formula_callable | |
| Cwfl::move_map_callable | |
| Cwfl::outcome_callable | |
| Cwfl::position_callable | |
| Cwfl::safe_call_result | |
| Cwfl::string_callable | |
| Cwfl::team_callable | |
| Cwfl::terrain_callable | |
| Cwfl::unit_callable | |
| Cwfl::unit_type_callable | |
| Cwfl::where_variables | |
| Cwfl::formula_debugger | |
| ►Cwfl::formula_expression | |
| Cwfl::decimal_expression | |
| Cwfl::dot_expression | |
| ►Cwfl::function_expression | |
| Cwfl::formula_function_expression | |
| Cwfl::function_list_expression | Classes that encapsulate and handle the various formula functions |
| Cwfl::identifier_expression | |
| Cwfl::integer_expression | |
| Cwfl::list_expression | |
| Cwfl::map_expression | |
| Cwfl::null_expression | |
| Cwfl::operator_expression | |
| Cwfl::square_bracket_expression | |
| Cwfl::string_expression | |
| Cwfl::unary_operator_expression | |
| Cwfl::where_expression | |
| Cwfl::wrapper_formula | |
| ►Cwfl::formula_function | |
| Cwfl::builtin_formula_function< T > | |
| Cwfl::user_formula_function | |
| Cutils::detail::formula_initer | |
| Cwfl::formula_input | |
| Cwfl::formula_variant_defines | |
| Canimated< T >::frame | |
| Cframe_builder | Easily build frame parameters with the serialized constructors |
| Cframe_parameters | All parameters from a frame at a given instant |
| Cframe_parsed_parameters | Keep most parameters in a separate class to simplify the handling of the large number of parameters between the frame level and animation level |
| Cpathfind::full_cost_map | Structure which uses find_routes() to build a cost map This maps each hex to a the movements a unit will need to reach this hex |
| Cspirit_po::default_plural_forms::function_object | |
| ►Cwfl::function_symbol_table | |
| Cwfl::action_function_symbol_table | |
| Cwfl::ai_function_symbol_table | |
| Cwfl::gamestate_function_symbol_table | |
| Cwb::future_map | Applies the planned unit map for the duration of the struct's life |
| Cwb::future_map_if | |
| Cwb::future_map_if_active | ONLY IF whiteboard is currently active, applies the planned unit map for the duration of the struct's life |
| Clua_formula_bridge::fwrapper | |
| Cwesnothd::game | |
| Cgame_classification | |
| Cgame_config_manager | |
| Ctest_utils::game_config_manager | |
| Cgame_config_view | A class grating read only view to a vector of config objects, viewed as one config with all children appended, used by the game_config class to read data from addons config, and from the main config |
| Cai::game_info | |
| Cmp::game_info | This class represents the info a client has about a game on the server |
| Cgame_launcher | |
| Cwesnothd::game_t | |
| Cgui2::game_tip | The tips of day structure |
| ►Cgamemap_base | |
| ►Cgamemap | Encapsulates the map of the game |
| Ceditor::editor_map | This class adds extra editor-specific functionality to a normal gamemap |
| Cmapgen_gamemap | |
| Creports::generator | |
| Cgenerator_data | |
| Cevents::generic_event | |
| ►Cai::goal_factory | |
| Cai::register_goal_factory< GOAL > | |
| ►Cspirit::qi::grammar | |
| Cspirit_po::catalog_metadata::content_type_grammar< Iterator > | |
| Cspirit_po::catalog_metadata::num_plurals_grammar< Iterator > | |
| Cspirit_po::po_grammar< Iterator > | |
| Cgui2::grid_implementation | Helper to implement private functions without modifying the header |
| Cgui2::group< T > | |
| Cgui2::group< preferences::lobby_joins > | |
| Cgui2::group< side_controller::type > | |
| Cgui2::group< std::string > | |
| Cgui2::group< team_shared_vision::type > | |
| Cgui2::group< unit_race::GENDER > | |
| Cgui2::grow_direction_defines | |
| Cutils::guard_value< T > | Data-based RAII scope guard |
| Cgui2::gui_definition | A GUI theme definition |
| Chalo::halo_impl | |
| Chalo::halo_record | RAII object which manages a halo |
| Chelp::has_id | To be used as a function object to locate sections and topics with a specified ID |
| Cstd::hash< color_t > | |
| Cstd::hash< font::pango_text > | |
| Cstd::hash< image::locator::value > | |
| Cstd::hash< map_location > | |
| ►Cutils::hash_base | |
| ►Cutils::hash_digest< 16 > | |
| Cutils::md5 | |
| ►Cutils::hash_digest< BCRYPT_HASHSIZE, char > | |
| Cutils::bcrypt | |
| Cutils::hash_digest< sz, T > | |
| Chelp::help_manager | The help implementation caches data parsed from the game_config |
| Cwb::highlighter | Class that handles highlighting planned actions as you hover over them and determine the right target for contextual execution |
| Cstatistics_record::stats_t::hitrate_t | |
| Cgui2::dialogs::hitrate_table_element | |
| Cai::holder | Base class that holds the AI and current AI parameters |
| ►Chotkey::hotkey_base | This is the base class for hotkey event matching |
| Chotkey::hotkey_keyboard | This class is responsible for handling keys, not modifiers |
| Chotkey::hotkey_mouse | This class is responsible for handling mouse button presses |
| Chotkey::hotkey_void | This class is used to return non-valid results in order to save other people from null checks |
| Chotkey::hotkey_command | Stores all information related to functions that can be bound to hotkeys |
| Chotkey::hotkey_command_temp | |
| Cn_unit::id_manager | |
| Cgui::indented_menu_item | The only kind of row still supported by the menu class |
| Cunit_abilities::individual_effect | |
| Ctexture::info | Small wrapper that queries metadata about the provided texture |
| ►Cvariable_info_implementation::info_visitor_base< R, P > | Visitor base class |
| Cvariable_info_implementation::as_array_visitor< V > | This currently isn't implemented as a range-based operation because doing it on something like range 2-5 on vi_policy_const if child_ has only 4 elements would be too hard to implement |
| Cvariable_info_implementation::as_container_visitor< V > | Tries to convert to a [const] config& |
| Cvariable_info_implementation::as_range_visitor_base< V, THandler, T > | |
| Cvariable_info_implementation::as_scalar_visitor< V > | Tries to convert it to an (maybe const) attribute value |
| Cvariable_info_implementation::clear_value_visitor< V > | |
| Cvariable_info_implementation::exists_as_container_visitor< V > | |
| Cvariable_info_implementation::get_variable_index_visitor< V > | Appends an [index] to the variable |
| Cvariable_info_implementation::get_variable_key_visitor< V > | Adds a ' |
| Cgui2::dialogs::lua_interpreter::input_model | The input_model keeps track of what commands were executed before, and figures out what should be displayed when the user presses up / down arrows in the input |
| Caddons_client::install_result | Contains the outcome of an add-on install operation |
| ►Cgui2::integer_selector | Small abstract helper class |
| Cgui2::slider | A slider is a control that can select a value by moving a grip on a groove |
| Cgui2::window::invalidate_layout_blocker | Helper class to block invalidate_layout |
| Cfont::inverse_table | |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_istream< Char > | STL class |
| Cpreprocessor_scope_helper | |
| Cutils::irdya_date | Calendar for handling and comparing dates using the common epoches of the storyline |
| Cimplementation::is_integral_v< std::remove_pointer_t< From > > >> | Specialized conversion class |
| Cis_translatable | |
| Cgui2::pane::item | |
| Cgui::menu::item | |
| Chelp::help_text_area::item | An item that is displayed in the text area |
| Chelp::help_text_area::item_at | Function object to find an item at the specified coordinates |
| Ceditor::item_group | Stores the info about the groups in a nice format |
| Cdisplay::rect_of_hexes::iterator | Very simple iterator to walk into the rect_of_hexes |
| Cgui2::grid::iterator | Iterator for the child items |
| Cucs4::iterator_base< string_type, update_implementation > | |
| Cunit_map::iterator_base< iter_types > | |
| ►Cboost::iterator_facade | |
| Cschema_validation::wml_tag::iterator< T, Map > | |
| Cucs4_convert_impl::iteratorwriter< oitor_t > | Transforms an output iterator to a writer for ucs4_convert_impl functions |
| Cjump_to_campaign_info | |
| ►Cai::known_aspect | |
| Cai::typesafe_known_aspect< T > | |
| Clanguage_def | |
| Cai::leader_aspects_visitor | |
| Cleave_synced_context | A RAII object to temporary leave the synced context like in wesnoth.synchronize_choice |
| ►Cng::level | Base class for all level type classes |
| Cng::campaign | |
| ►Cng::scenario | |
| Cng::random_map | |
| Cng::user_map | |
| Clevel_result_defines | |
| Clevel_type_defines | |
| Cimplementation::lexical_caster< To, From, ToEnable, FromEnable > | Base class for the conversion |
| Cimplementation::lexical_caster< bool, From, void, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< bool, std::string > | Specialized conversion class |
| Cimplementation::lexical_caster< long long, From, void, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< long long, std::string > | Specialized conversion class |
| Cimplementation::lexical_caster< To, From, std::enable_if_t< std::is_floating_point_v< To > >, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< To, From, std::enable_if_t< std::is_integral_v< To > &&std::is_signed_v< To > &&!std::is_same_v< To, long long > >, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< To, From, std::enable_if_t< std::is_unsigned_v< To > &&!std::is_same_v< To, unsigned long long > >, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< To, std::string, std::enable_if_t< std::is_floating_point_v< To > > > | Specialized conversion class |
| Cimplementation::lexical_caster< To, std::string, std::enable_if_t< std::is_integral_v< To > &&std::is_signed_v< To > &&!std::is_same_v< To, long long > > > | Specialized conversion class |
| Cimplementation::lexical_caster< To, std::string, std::enable_if_t< std::is_unsigned_v< To > > > | Specialized conversion class |
| Cimplementation::lexical_caster< unsigned long long, From, void, std::enable_if_t< std::is_same_v< From, const char * >||std::is_same_v< From, char * > > > | Specialized conversion class |
| Cimplementation::lexical_caster< unsigned long long, std::string > | Specialized conversion class |
| Cgui2::linked_group_definition | |
| Cgui2::window::linked_size | Helper struct to force widgets the have the same size |
| Csavegame::load_game_metadata | |
| Csavegame::loadgame | The class for loading a savefile |
| Cgui2::lobby_chat_window | |
| Cgui2::dialogs::lobby_delay_gamelist_update_guard | |
| Cmp::lobby_info | This class represents the collective information the client has about the players and games on the server |
| Cgui2::lobby_player_list_helper | |
| Cimage::locator | Generic locator abstracting the location of an image |
| Clg::log_domain | |
| Clg::log_in_progress | |
| Clg::logger | |
| Clogin_info | |
| Cwesnothd::server::login_log | |
| Cai::lua_ai_action_handler | Proxy class for calling AI action handlers defined in Lua |
| Cai::lua_ai_context | Proxy table for the AI context |
| Cai::lua_ai_load | |
| ►Cai::lua_aspect_factory | |
| Cai::register_lua_aspect_factory< ASPECT > | |
| Cai::lua_aspect_visitor | |
| Clua_context_backend | |
| Clua_fileops::lua_filestream | |
| Clua_index_raw | |
| ►Clua_jailbreak_exception | Base class for exceptions that want to be thrown 'through' lua |
| Cfallback_ai_to_human_exception | |
| Cgui2::iteration::logic_error | Thrown when deferring an invalid iterator |
| Cgui2::iteration::range_error | Thrown when moving an invalid iterator |
| Cimage::modification::imod_exception | Exception thrown by the operator() when an error occurs |
| Cingame_wesnothd_error | We received invalid data from wesnothd during a game This means we cannot continue with the game but we can stay connected to wesnothd and start a new game |
| Cleavegame_wesnothd_error | |
| Cquit_game_exception | |
| Creset_gamestate_exception | |
| Creturn_to_play_side_exception | Exception used to escape form the ai or ui code to playsingle_controller::play_side |
| Csavegame::load_game_exception | Exception used to signal that the user has decided to abortt a game, and to load another game instead |
| Cvideo::quit | Type that can be thrown as an exception to quit to desktop |
| Cwesnothd_connection_error | An error occurred inside the underlying network communication code (boost asio) TODO: find a short name |
| Cwml_exception | Helper class, don't construct this directly |
| ►Clua_kernel_base | |
| Capplication_lua_kernel | |
| Cgame_lua_kernel | |
| Cmapgen_lua_kernel | |
| Clua_map_ref | |
| Cgui2::dialogs::lua_interpreter::lua_model | The lua model is responsible to interact with the lua kernel base and keep track of what should be displayed in the console |
| Clua_music_track | |
| ►Cai::lua_object_base | |
| Cai::lua_object< T > | |
| Clua_ptr< T > | Tmust inherit enable_lua_ptr<T> |
| Clua_sound_source | |
| Clua_unit | Storage for a unit, either owned by the Lua code (ptr != 0), a local variable unit (c_ptr != 0), on a recall list (side != 0), or on the map |
| Cai::manager | Class that manages AIs for all sides and manages AI redeployment |
| Ccursor::manager | |
| Cfont::manager | |
| Cgame_events::manager | The game event manager loads the scenario configuration object, and ensures that events are handled according to the scenario configuration for its lifetime |
| Cgui2::event::manager | |
| Chalo::manager | |
| Chotkey::manager | This class is initialized once at game start put all initialization and wipe code in the methods here |
| Cimage::manager | Image cache manager |
| Cng::depcheck::manager | Note to all triers: It's not guaranteed that the specified component will be selected (if the user denies to perform dependency resolution, all changes will be reverted) |
| Cpathfind::manager | |
| Cpreferences::manager | |
| Cwb::manager | This class is the frontend of the whiteboard framework for the rest of the Wesnoth code |
| Cevents::map_command_handler< Worker > | |
| ►Cevents::map_command_handler< chat_command_handler > | |
| ►Cevents::chat_command_handler | |
| Cevents::console_handler | |
| ►Cevents::map_command_handler< console_handler > | |
| Cevents::console_handler | |
| Ceditor::map_fragment | A map fragment – a collection of locations and information abut them |
| ►Cmap_generator | |
| Ccave_map_generator | |
| Cdefault_map_generator | |
| Clua_map_generator | |
| Cmap_labels | |
| ►Cmap_location | Encapsulates the map of the game |
| Cgame_events::entity_location | |
| Cmap_locker | |
| Cwb::mapbuilder | Class that collects and applies unit_map modifications from the actions it visits and reverts all changes on destruction |
| Cpathfind::marked_route::mark | |
| Cpathfind::marked_route | Structure which holds a single route and marks for special events |
| ►Cmaximum_selection | |
| Cgui2::generator< minimum_selection, maximum_selection, my_placement, select_action > | Basic template class to generate new items |
| Cvariable_info_implementation::maybe_const< config::child_itors, const vi_policy_const > | |
| Cvariable_info_implementation::merge_range_h | |
| ►Cgui2::event::message | The message callbacks hold a reference to a message |
| Cgui2::event::message_show_helptip | The message for MESSAGE_SHOW_HELPTIP |
| Cgui2::event::message_show_tooltip | The message for MESSAGE_SHOW_TOOLTIP |
| Cgui2::dialogs::message_implementation | Helper to implement private functions without modifying the header |
| Cschema_validation::schema_validator::message_info | Messages are cached |
| Cmetrics | |
| ►Cminimum_selection | |
| Cgui2::generator< minimum_selection, maximum_selection, my_placement, select_action > | Basic template class to generate new items |
| CMLFixture | |
| Cgui2::dialogs::chat_log::model | |
| Cgui2::dialogs::gamestate_inspector::model | |
| ►Cimage::modification | Base abstract class for an image-path modification |
| Cimage::adjust_alpha_modification | Adjust Alpha (ADJUST_ALPHA) modification |
| Cimage::adjust_channels_modification | Adjust Channels (CHAN) modification |
| Cimage::background_modification | Fill background with a color (BG) |
| Cimage::bl_modification | Gaussian-like blur (BL) modification |
| Cimage::blend_modification | Color blending (BLEND) modification |
| Cimage::blit_modification | Scale (BLIT) modification |
| Cimage::bw_modification | Black and white (BW) modification |
| Cimage::crop_modification | Crop (CROP) modification |
| Cimage::crop_transparency_modification | Crop transparent padding (CROP_TRANSPARENCY) modification |
| Cimage::cs_modification | Color-shift (CS, R, G, B) modification |
| Cimage::fl_modification | Mirror (FL) modification |
| Cimage::gs_modification | Grayscale (GS) modification |
| Cimage::light_modification | LIGHT (L) modification |
| Cimage::mask_modification | Mask (MASK) modification |
| Cimage::negative_modification | Make an image negative (NEG) |
| Cimage::o_modification | Opacity (O) modification |
| Cimage::plot_alpha_modification | Plot Alpha (Alpha) modification |
| Cimage::rc_modification | Recolor (RC/TC/PAL) modification |
| Cimage::rotate_modification | Rotate (ROTATE) modification |
| Cimage::scale_modification | Scaling (SCALE[_INTO], SCALE[_INTO]_SHARP) modifications |
| Cimage::sepia_modification | Give to the image a sepia tint (SEPIA) |
| Cimage::swap_modification | Channel swap (SWAP) |
| Cimage::wipe_alpha_modification | Wipe Alpha (Wipe_Alpha) modification |
| Cimage::xbrz_modification | XBRZ scale (xBRZ) modification |
| Cimage::modification_queue | A modified priority queue used to order image modifications |
| ►Ceditor::mouse_action | A mouse action receives events from the controller, and responds to them by creating an appropriate editor_action object |
| ►Ceditor::brush_drag_mouse_action | A brush-drag mouse action base class which adds brush and drag processing to a basic mouse action |
| Ceditor::mouse_action_paint | Brush paint mouse action |
| Ceditor::mouse_action_select | Select (and deselect) action, by brush or "magic wand" (via keyboard modifier) |
| Ceditor::mouse_action_fill | Fill action |
| Ceditor::mouse_action_item | Item placement action class |
| Ceditor::mouse_action_map_label | Set map label action |
| Ceditor::mouse_action_paste | Paste action |
| Ceditor::mouse_action_starting_position | Set starting position action |
| Ceditor::mouse_action_unit | Unit placement action class |
| Ceditor::mouse_action_village | Editor mouse action class |
| ►Cevents::mouse_handler_base | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cevents::mouse_handler | |
| ►Cgui2::event::mouse_motion | |
| ►Cgui2::event::mouse_button< I > | |
| Cgui2::event::distributor | The event handler class for the widget library |
| Cgui2::event::distributor | The event handler class for the widget library |
| Cgui2::event::distributor | The event handler class for the widget library |
| Cwfl::position_callable::move_map_backup | |
| Cactions::move_unit_spectator | |
| Cmovetype | The basic "size" of the unit - flying, small land, large land, etc |
| Cmp_connect_fixture | |
| Cmp_game_metadata | |
| Cmp_game_settings | |
| Cgui2::dialogs::mp_options_helper | |
| Crandomness::mt_rng | |
| Csound::music_track | Internal representation of music tracks |
| ►Cmy_placement | |
| Cgui2::generator< minimum_selection, maximum_selection, my_placement, select_action > | Basic template class to generate new items |
| Cspirit_po::default_plural_forms::n_var | |
| ►Cname_generator | |
| Ccontext_free_grammar_generator | |
| Cmarkov_generator | |
| Cproxy_name_generator | |
| Cname_generator_factory | |
| Cpersist_context::name_space | |
| Cwesnothd::name_t | |
| Cmp::network_registrar | RAII helper class to register a network handler |
| Cterrain_filterimpl::no_filter | |
| Cterrain_filterimpl::no_start_set_yet | |
| Csimple_wml::node | |
| Csimple_wml::node::node_pos | |
| Ccontext_free_grammar_generator::nonterminal | |
| Cspirit_po::default_plural_forms::not_op | |
| Cgui2::notifiee< FUNCTOR > | Helper class to implement callbacks with lifetime management |
| Cgui2::notifiee< functor_t > | |
| Cgui2::notifier< FUNCTOR > | Helper class to implement callbacks with lifetime management |
| Cgui2::notifier< functor_t > | |
| ►CNSApplication | |
| CWesnothSDLApplication | |
| ►CNSObject | |
| CSDLMain | |
| Cwb::side_actions::numbers_t | |
| ►Cstd::numeric_limits | |
| ►Crandomness::rng | This class does not give synced random results derived classes might do |
| Crandomness::rng_deterministic | This rng is used when the normal synced rng is not available this is currently only he case at the very start of the scenario (random generation of starting units traits) |
| Crandomness::synced_rng | |
| ►Ctheme::object | |
| Ctheme::action | |
| Ctheme::label | |
| Ctheme::menu | |
| Ctheme::panel | |
| Ctheme::slider | |
| Ctheme::status_item | |
| ►Cevents::observer | |
| Cai::aspect | |
| Cai::default_recruitment::recruitment::recruit_situation_change_observer | |
| Cai::gamestate_observer | |
| Cai::keeps_cache | |
| Cai::readonly_context_impl | |
| Cgui2::dialogs::synched_choice_wait | |
| ►Cplay_controller | |
| ►Cplaysingle_controller | |
| Cplaymp_controller | |
| Creplay_controller | |
| Csoundsource::manager | |
| Cutils::optimer< ResolutionType, ClockType > | Reports time elapsed at the end of an object scope |
| Cpreferences::advanced_manager::option | |
| Cgui2::dialogs::mp_options_helper::option_source | |
| Coptional_config_impl< T > | |
| Coptional_config_impl< const config > | |
| Cgame_config::optional_feature | |
| Cutils::optional_reference< T > | A simple wrapper class for optional reference types |
| Cutils::optional_reference< const unit_type > | |
| Cutils::optional_reference< events::mouse_handler > | |
| Cutils::optional_reference< gui2::window > | |
| ►Corder | |
| Cgui2::iteration::iterator< order > | The iterator class |
| Cfilesystem::other_version_dir | |
| Coverlay | |
| Cgamemap_base::overlay_rule | |
| Cfont::p_font | Small helper class to make sure the pango font object is destroyed properly |
| ►Cstd::pair | |
| Ctwo_strings | |
| Cgui2::pane_implementation | Helper to implement private functions without modifying the header |
| Cfont::pango_text | Text class |
| Cmovetype::terrain_info::parameters | The parameters used when calculating a terrain-based value |
| Ccave_map_generator::cave_map_generator_job::passage | |
| Cai::path_element | |
| Cai::path_element_matches< T > | |
| Cdesktop::path_info | |
| ►Cpathfind::paths | Object which contains all the possible locations a unit can move to, with associated best routes to those locations |
| Cpathfind::jamming_path | A refinement of paths for use when calculating jamming |
| Cpathfind::vision_path | A refinement of paths for use when calculating vision |
| Cgame_events::pending_event_handler | Represents a handler that is about to be added to the events manager but is still waiting for some data |
| ►Cpersist_context | |
| Cpersist_file_context | |
| Cpersist_manager | |
| ►Cgui2::placer_base | Base class for the placement helper |
| Cgui2::implementation::placer_horizontal_list | The placement class for a horizontal list |
| Cgui2::implementation::placer_vertical_list | The placement class for a vertical list |
| Cplacing_info | |
| Cpathfind::plain_route | Structure which holds a single route between one location and another |
| Cgame_history::player | |
| Cwesnothd::player | |
| Cgui2::player_list_helper | |
| Cwesnothd::player_record | |
| Cplayturn_network_adapter | |
| Cplugin | |
| ►Cgui2::dialogs::plugin_executor | |
| Cgui2::dialogs::mp_create_game | |
| Cgui2::dialogs::mp_join_game | |
| Cgui2::dialogs::mp_lobby | |
| Cgui2::dialogs::mp_staging | |
| Cgui2::dialogs::sp_options_configure | |
| Cplugin_manager_status_defines | |
| Cplugins_context | |
| Cplugins_manager | |
| Cspirit_po::po_message | |
| Cvconfig::all_children_iterator::pointer_proxy | |
| Cvconfig::attribute_iterator::pointer_proxy | |
| Csoundsource::positional_source | |
| Cpreproc_config | |
| Cpreproc_define | |
| ►Cpreprocessor | Base class for preprocessing an input |
| Cpreprocessor_data | Specialized preprocessor for handling any kind of input stream |
| Cpreprocessor_file | Specialized preprocessor for handling a file or a set of files |
| ►Cprogressive_base< T, D > | |
| Cprogressive_pair< double > | |
| Cprogressive_pair< int > | |
| Cprogressive_single< std::string > | |
| Cprogressive_single< image::locator > | |
| ►Cprogressive_base< T, std::pair< T, T > > | |
| Cprogressive_pair< T > | |
| ►Cprogressive_base< T, T > | |
| Cprogressive_single< T > | |
| Cgame_events::pump_impl | |
| Cevents::pump_info | |
| ►Cevents::pump_monitor | |
| ►Ccontroller_base | |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cplay_controller | |
| Ccountdown_clock | |
| Cgui2::dialogs::loading_screen | |
| Cgui2::dialogs::network_transmission::pump_monitor | |
| Csound::music_thinker | |
| Cuser_choice_manager | |
| Chotkey::command_executor::queued_command | |
| Cgame_events::queued_event | |
| ►Cquit_confirmation | Implements a quit confirmation dialog |
| Ceditor::editor_controller | Mouse and keyboard event handling routines for the editor |
| Cgui2::dialogs::mp_lobby | |
| Cplay_controller | |
| Crandom_faction_mode_defines | |
| Cai::ai_default_rca::rated_target | |
| Cai::ai_default_rca::rated_target_comparer | |
| Cwb::real_map | Ensures that the real unit map is active for the duration of the struct's life |
| Crecall_list_manager | This class encapsulates the recall list of a team |
| Cdisplay::rect_of_hexes | Rectangular area of hexes, allowing to decide how the top and bottom edges handles the vertical shift for each parity of the x coordinate |
| Cai::recursion_counter | |
| Clg::redirect_output_setter | Helper class to redirect the output of the logger in a certain scope |
| Cn_ref_counter::ref_counter< T_integral > | Ref_counter is a reference counter |
| Cn_ref_counter::ref_counter< signed int > | |
| Cschema_validation::schema_self_validator::reference | |
| Clua_cpp::Reg | |
| Cplugins_context::Reg | |
| Cgui2::registered_widget_parser | |
| Cai::ai_default_rca::remove_wrong_targets | |
| Cdraw::render_target_setter | A class to manage automatic restoration of the render target |
| ►Cvariable_info_implementation::replace_range_h | Replaces the child in [startindex, endindex) with 'source' 'insert' and 'append' are subcases of this |
| ►Cvariable_info_implementation::insert_range_h | |
| Cvariable_info_implementation::append_range_h | |
| Creplay | |
| Creplay_helper | |
| Creplay_recorder_base | |
| Creplay_controller::replay_stop_condition | |
| Creport_generator_helper | |
| Creports | |
| Ccampaignd::server::request | Client request information object |
| Cmp::game_info::required_addon | |
| Cutils::res_compare | |
| Cmovetype::resistances | Stores a set of resistances |
| ►Cgui2::resolution_definition | Base class of a resolution, contains the common keys for a resolution |
| Cgui2::addon_list_definition::resolution | |
| Cgui2::button_definition::resolution | |
| Cgui2::chatbox_definition::resolution | |
| Cgui2::drawing_definition::resolution | |
| Cgui2::horizontal_scrollbar_definition::resolution | |
| Cgui2::image_definition::resolution | |
| Cgui2::label_definition::resolution | |
| Cgui2::listbox_definition::resolution | |
| Cgui2::matrix_definition::resolution | |
| Cgui2::menu_button_definition::resolution | |
| Cgui2::minimap_definition::resolution | |
| Cgui2::multi_page_definition::resolution | |
| Cgui2::multiline_text_definition::resolution | |
| Cgui2::multimenu_button_definition::resolution | |
| ►Cgui2::panel_definition::resolution | |
| Cgui2::window_definition::resolution | |
| Cgui2::progress_bar_definition::resolution | |
| Cgui2::repeating_button_definition::resolution | |
| Cgui2::scroll_label_definition::resolution | |
| Cgui2::scroll_text_definition::resolution | |
| Cgui2::scrollbar_panel_definition::resolution | |
| Cgui2::size_lock_definition::resolution | |
| Cgui2::slider_definition::resolution | |
| Cgui2::spacer_definition::resolution | |
| Cgui2::spinner_definition::resolution | |
| Cgui2::stacked_widget_definition::resolution | |
| Cgui2::text_box_definition::resolution | |
| Cgui2::toggle_button_definition::resolution | |
| Cgui2::toggle_panel_definition::resolution | |
| Cgui2::tree_view_definition::resolution | |
| Cgui2::unit_preview_pane_definition::resolution | |
| Cgui2::vertical_scrollbar_definition::resolution | |
| Cgui2::event::resource_locker | Small helper to keep a resource (boolean) locked |
| Cgame_history::result | |
| ►Crs_base | |
| Cban_check | |
| Cgame_history | |
| Ctournaments | |
| Cterrain_builder::rule_image | Each terrain_graphics rule is associated a set of images, which are applied on the terrain if the rule matches |
| Cterrain_builder::tile::rule_image_rand | Represent a rule_image applied with a random seed |
| Cterrain_builder::rule_image_variant | An image variant |
| Cmetrics::sample | |
| Csave_blocker | While any instance of this class exists, attempts to save the game via any call to play_controller will be temporarily postponed: the call will return immediately without performing the save, but the save method will then be reinvoked from this class's destructor |
| Csave_id_equals | |
| Cevents::save_id_matches | |
| Csavegame::save_info | Filename and modification date for a file list |
| Csavegame::save_info_less_time | A structure for comparing to save_info objects based on their modified time |
| Csave_blocker::save_unblocker | An exception-safe means of making sure that unblock() gets called after try_block() |
| Csaved_game | |
| Csaved_game_mode_defines | |
| ►Csavegame::savegame | The base class for all savegame stuff |
| ►Csavegame::ingame_savegame | Class for "normal" midgame saves |
| Csavegame::autosave_savegame | Class for autosaves |
| Csavegame::oos_savegame | |
| Csavegame::replay_savegame | Class for replay saves (either manually or automatically) |
| Csavegame::scenariostart_savegame | Class for start-of-scenario saves |
| Cxbrz::ScalerCfg | |
| Cstatistics_record::scenario_stats_t | |
| Chotkey::scope_changer | |
| Cutils::scope_exit< F > | |
| Cutils::scope_exit_syntax_support | |
| Clg::scope_logger | |
| Cgame_events::context::scoped | |
| Cgame_config::scoped_preproc_define_internal< T > | Used to set and unset scoped defines to preproc_map |
| Cgame_config::scoped_preproc_define_internal< test_config_cache > | |
| Cplay_controller::scoped_savegame_snapshot | |
| ►Cscoped_wml_variable | |
| Cscoped_recall_unit | |
| Cscoped_weapon_info | |
| Cscoped_xy_unit | |
| Cgui2::scrollbar_container_implementation | Helper to implement private functions without modifying the header |
| ►CSDL_Color | |
| Ccolor_t | The basic class for representing 8-bit RGB or RGBA colour values |
| ►Cevents::sdl_handler | |
| Ccontroller_base | |
| Ccontroller_base::keyup_listener | |
| Cgui2::event::sdl_event_handler | This singleton class handles all events |
| ►Cgui::widget | |
| ►Ceditor::common_palette | |
| Ceditor::empty_palette | Empty palette |
| Ceditor::location_palette | List of starting locations and location ids |
| ►Ceditor::tristate_palette | |
| ►Ceditor::editor_palette< t_translation::terrain_code > | |
| Ceditor::terrain_palette | Palette where the terrain to be drawn can be selected |
| ►Ceditor::editor_palette< const unit_type & > | |
| Ceditor::unit_palette | Palette where the terrain to be drawn can be selected |
| ►Ceditor::editor_palette< overlay > | |
| Ceditor::item_palette | Palette where the terrain to be drawn can be selected |
| Ceditor::editor_palette< Item > | |
| Ceditor::palette_manager | Empty palette |
| ►Cgui::button | A button is a control that can be pushed to start an action or close a dialog |
| Clocation_palette_button | |
| ►Cgui::scrollarea | |
| ►Cgui::menu | Superclass of the help_menu, which displays the left-hand pane of the GUI1 help browser |
| Chelp::help_menu | The menu to the left in the help browser, where topics can be navigated through and chosen |
| Cgui::textbox | |
| Chelp::help_text_area | The area where the content is shown in the help browser |
| Cgui::scrollbar | Scrollbar |
| Cgui::tristate_button | |
| Chelp::help_browser | A help browser widget |
| Clocation_palette_item | |
| Cpreferences::prefs_event_handler | |
| Csound::music_muter | |
| ►CSDL_Point | |
| Cpoint | Holds a 2D point |
| ►CSDL_Rect | |
| Crect | An abstract description of a rectangle with integer coordinates |
| Cfilesystem::sdl_rwops_deleter | |
| Chelp::section | A section contains topics and sections along with title and ID |
| Chelp::section_less | To be used as a function object when sorting section lists on the title |
| ►Cselect_action | |
| Cgui2::generator< minimum_selection, maximum_selection, my_placement, select_action > | Basic template class to generate new items |
| ►Cgui2::selectable_item | Small abstract helper class |
| Cgui2::menu_button | A menu_button is a styled_widget to choose an element from a list of elements |
| Cgui2::toggle_button | Class for a toggle button |
| Cgui2::toggle_panel | Class for a toggle button |
| Cgui2::dialogs::mp_connect::selection | |
| ►Cserver_base | Base class for implementing servers that use gzipped-WML network protocol |
| Ccampaignd::server | Legacy add-ons server |
| Cwesnothd::server | |
| Csynced_context::server_choice | |
| Cgame_config::server_info | |
| Cplaysingle_controller::ses_result | |
| Crandomness::set_random_determinstic | RAII class to use rng_deterministic in the current scope |
| ►Cset_scontext_synced_base | |
| Cset_scontext_synced | A RAII object to enter the synced context, cannot be called if we are already in a synced context |
| Cset_scontext_unsynced | An object to leave the synced context during draw or unsynced wml items when we don’t know whether we are in a synced context or not |
| ►Ccursor::setter | |
| Cgui::dialog_manager | |
| ►Cgui2::canvas::shape | Abstract base class for all other shapes |
| Cgui2::circle_shape | Definition of a circle |
| Cgui2::image_shape | Keys: |
| Cgui2::line_shape | Definition of a line |
| ►Cgui2::rect_bounded_shape | Class holding common attribute names (for WML) and common implementation (in C++) for shapes placed with the 4 attributes x, y, w and h |
| Cgui2::rectangle_shape | Definition of a rectangle |
| Cgui2::round_rectangle_shape | Definition of a rounded rectangle shape |
| Cgui2::text_shape | |
| Cutils::shared_reference< T > | |
| Cactions::shroud_clearer | Class to encapsulate fog/shroud clearing and the resultant sighted events |
| ►Cactions::shroud_clearing_action | Base class for classes that clear srhoud (move/recruit/recall) |
| Cactions::undo::move_action | |
| Cactions::undo::recall_action | |
| Cactions::undo::recruit_action | |
| Cshroud_map | |
| Cwb::side_actions_container | Datastructure holding the actions of a side on multiple turns |
| ►Cai::side_context | |
| ►Cai::readonly_context | |
| Cai::readonly_context_impl | |
| ►Cai::readonly_context_proxy | |
| Cai::aspect | |
| Cai::formula_ai | |
| Cai::goal | |
| Cai::readwrite_context_impl | |
| ►Cai::readwrite_context_proxy | |
| Cai::default_ai_context_impl | |
| ►Cai::default_ai_context_proxy | |
| Cai::ai_composite | |
| ►Cai::ai_context_proxy | |
| ►Cai::rca_context_proxy | |
| Cai::candidate_action | |
| Cai::stage | |
| ►Cai::readwrite_context | |
| ►Cai::default_ai_context | |
| ►Cai::ai_context | |
| Cai::ai_composite | |
| Cai::ai_context_proxy | |
| ►Cai::rca_context | |
| Cai::ai_default_rca::candidate_action_evaluation_loop | |
| Cai::candidate_action_context | |
| Cai::rca_context_proxy | |
| Cai::default_ai_context_impl | |
| Cai::default_ai_context_proxy | |
| Cai::readwrite_context_impl | |
| Cai::readwrite_context_proxy | |
| Cai::side_context_impl | |
| ►Cai::side_context_proxy | |
| Cai::readonly_context_impl | |
| Cai::readonly_context_proxy | |
| Cside_controller_defines | |
| Cng::side_engine | |
| Cside_filter | |
| Cside_proxy_controller_defines | |
| Cactions::shroud_clearer::sight_data | A record of a sighting event |
| Cgui2::event::dispatcher::signal_queue< T > | Helper struct to generate the various event queues |
| Cgui2::event::dispatcher::signal_queue< signal > | |
| Cgui2::event::dispatcher::signal_queue< signal_keyboard > | |
| Cgui2::event::dispatcher::signal_queue< signal_message > | |
| Cgui2::event::dispatcher::signal_queue< signal_mouse > | |
| Cgui2::event::dispatcher::signal_queue< signal_notification > | |
| Cgui2::event::dispatcher::signal_queue< signal_raw_event > | |
| Cgui2::event::dispatcher::signal_queue< signal_text_input > | |
| Cgui2::event::dispatcher::signal_queue< signal_touch_gesture > | |
| Cgui2::event::dispatcher::signal_queue< signal_touch_motion > | |
| Cgui2::event::dispatcher::signal_type< T > | Helper struct to generate the various signal types |
| ►Cgui2::dialogs::single_mode_controller | |
| Cgui2::dialogs::event_mode_controller | |
| Cgui2::dialogs::team_mode_controller | |
| Cgui2::dialogs::unit_mode_controller | |
| Cgui2::dialogs::variable_mode_controller | |
| ►Cgui2::iteration::policy::visit::skip_level | This policy skips the current level |
| Cgui2::iteration::policy::visit_level< false, level > | Specialized to select the visit::skip_level policy |
| Cgui2::slider_base::slider_position_t | Helper container for the slider's current position |
| Cwesnothd::socket_t | |
| Csort_order_defines | |
| Csoundsource::sourcespec | Sound source info class |
| Cattack_type::specials_context_t | |
| Cgui2::stacked_widget_implementation | |
| ►Cai::stage_factory | |
| Cai::register_stage_factory< STAGE > | |
| Cunit_map::standard_iter_types | |
| Cgame_events::context::state | State when processing a particular flight of events or commands |
| ►CSTATE | |
| Cgui2::control_NEW< STATE > | |
| Cgui2::state_default | |
| Cgui2::state_definition | Contains the state info for a resolution |
| Clocation_palette_item::state_t | |
| ►Cboost::static_visitor | |
| Cspirit_po::default_plural_forms::evaluator | |
| Cstatistics_attack_context | |
| Cstatistics_t | |
| Cstatistics_record::stats_t | |
| Cpathfind::paths::step | |
| ►Cstoryscreen::story_parser | Small helper class to encapsulate the common logic for parsing storyscreen WML |
| Cstoryscreen::controller | |
| Cstoryscreen::part | Represents and contains information about a single storyscreen part |
| ►Cstd::streambuf | |
| Cpreprocessor_streambuf | Target for sending preprocessed output |
| Cstrike_result_defines | |
| Chelp::string_less | |
| Csimple_wml::string_span | |
| Cconfig_attribute_value::string_visitor | Visitor for converting a variant to a string |
| Cgui2::dialogs::stuff_list_adder | |
| Cgui::dialog_frame::style | |
| ►Cgui::menu::style | |
| Cgui::menu::imgsel_style | |
| ►Cgui2::styled_widget_definition | |
| Cgui2::addon_list_definition | |
| Cgui2::button_definition | |
| Cgui2::chatbox_definition | |
| Cgui2::drawing_definition | |
| Cgui2::horizontal_scrollbar_definition | |
| Cgui2::image_definition | |
| Cgui2::label_definition | |
| Cgui2::listbox_definition | |
| Cgui2::matrix_definition | |
| Cgui2::menu_button_definition | |
| Cgui2::minimap_definition | |
| Cgui2::multi_page_definition | |
| Cgui2::multiline_text_definition | |
| Cgui2::multimenu_button_definition | |
| Cgui2::panel_definition | |
| Cgui2::progress_bar_definition | |
| Cgui2::repeating_button_definition | |
| Cgui2::scroll_label_definition | |
| Cgui2::scroll_text_definition | |
| Cgui2::scrollbar_panel_definition | |
| Cgui2::size_lock_definition | |
| Cgui2::slider_definition | |
| Cgui2::spacer_definition | |
| Cgui2::spinner_definition | |
| Cgui2::stacked_widget_definition | |
| Cgui2::text_box_definition | |
| Cgui2::toggle_button_definition | |
| Cgui2::toggle_panel_definition | |
| Cgui2::tree_view_definition | |
| Cgui2::unit_preview_pane_definition | |
| Cgui2::vertical_scrollbar_definition | |
| Cgui2::window_definition | |
| Csub_achievement | Represents a distinct sub-achievement within another achievement |
| Cgui2::lobby_player_list_helper::sub_list | |
| Csubmerge_data | |
| Cfont::subset_descriptor | |
| Cwfl::string_expression::substitution | |
| Csurface | |
| Csurface_locker< T > | Helper class for pinning SDL surfaces into memory |
| Csymbol_table | |
| Csynced_command | |
| Csynced_context | |
| Ct_string | |
| Ct_string_base | Helper class for translatable strings |
| Cai::target | |
| Cteam | This class stores all the data for a single 'side' (in game nomenclature) |
| Cteam_builder | |
| Cteam_data | |
| Cng::connect_engine::team_data_pod | |
| Cteam::team_info | |
| Cteam_shared_vision_defines | |
| Cpathfind::teleport_group | |
| Cpathfind::teleport_map | |
| Cwb::temporary_unit_hider | |
| Ctemporary_unit_mover | This object is used to temporary move a unit in the unit map, swapping out any unit that is already there |
| Ctemporary_unit_placer | This object is used to temporary place a unit in the unit map, swapping out any unit that is already there |
| Ctemporary_unit_remover | This object is used to temporary remove a unit from the unit map |
| Ct_translation::ter_map | |
| Ct_translation::ter_match | This structure can be used for matching terrain strings |
| Cspirit_po::default_plural_forms::ternary_op | |
| Cterrain_builder | The class terrain_builder is constructed from a config object, and a gamemap object |
| Ct_translation::terrain_code | A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separated by a caret and each group consists of 2 to 4 characters if no second layer is defined it is stored as 0xFFFFFFFF, if the second layer is empty (needed for matching) the layer has the value 0 |
| Cterrain_builder::terrain_constraint | The in-memory representation of a [tile] WML rule inside of a [terrain_graphics] WML rule |
| ►Cmovetype::terrain_costs | A const-only interface for how many (movement, vision, or "jamming") points a unit needs for each hex |
| Cmovetype::terrain_info | Stores a set of data based on terrain, in some cases with raw pointers to other instances of terrain_info (the fallback_) |
| Cmovetype::terrain_defense | Stores a set of defense levels |
| Cterrain_filter::terrain_filter_cache | |
| Cterrain_filterimpl | |
| Cterrain_label | To store label data Class implements logic for rendering |
| Cterrain_movement | |
| Chelp::terrain_movement_info | |
| Cterrain_type | |
| Cterrain_type_data | Contains the database of all known terrain types, both those defined explicitly by WML [terrain_type]s and those made by combining pairs of (base, overlay) |
| Ctest_gui2_fixture | |
| Cgui2::text_history | Class for text input history |
| Ctexture | Wrapper class to encapsulate creation and management of an SDL_Texture |
| Ctheme | |
| Ctheme_info | |
| Capplication_lua_kernel::thread | |
| Cterrain_builder::tile | Represents a tile of the game map, with all associated builder-specific parameters: flags, images attached to this tile, etc |
| Ceditor::tile_info | This represents a tile along with information about it, namely the terrain, possibly other information |
| Cterrain_builder::tilemap | The map of "tile" structures corresponding to the level map |
| Cgui2::dialogs::debug_clock::time | Helper struct to keep track of the time |
| Ctime_of_day | Object which defines a time of day with associated bonuses, image, sounds etc |
| Cgui2::timer | |
| Chelp::title_less | To be used as a function object when sorting topic lists on the title |
| Ctmp_file | Self destructive temporary file at the current directory |
| Ctod_color | Small struct to store and manipulate ToD color adjusts |
| Ctod_manager | |
| Ctoken | |
| Cwfl::tokenizer::token | |
| Cpreprocessor_data::token_desc | Description of a preprocessing chunk |
| Cwfl::tokenizer::token_error | |
| Ctokenizer | Abstract baseclass for the tokenizer |
| Cgui2::builder_window::window_resolution::tooltip_info | Helper struct to store information about the tips |
| ►Cgui2::top_level_drawable | A top-level drawable item (TLD), such as a window |
| ►Cdisplay | Sort-of-Singleton that many classes, both GUI and non-GUI, use to access the game data |
| Ceditor::editor_display | |
| Cgame_display | |
| Cgui2::window | Base class of top level items, the only item which needs to store the final canvases to draw on |
| Cgui::dialog_frame | |
| Cgui::widget | |
| Ctooltips::manager | |
| Chelp::topic | A topic contains a title, an id and some text |
| ►Chelp::topic_generator | Generate a topic text on the fly |
| Chelp::terrain_topic_generator | |
| Chelp::text_topic_generator | |
| Chelp::unit_topic_generator | |
| Chelp::topic_text | The text displayed in a topic |
| Ctransient_end_level | The non-persistent part of end_level_data |
| Cgui2::implementation::tree_node | |
| Cgui2::tree_view_node_implementation | |
| Cconfig_attribute_value::true_false | A wrapper for bool to get the correct streaming ("true"/"false") |
| ►Cstd::true_type | |
| Clua_check_impl::is_container< T, std::void_t< typename std::decay_t< T >::value_type, typename std::decay_t< T >::iterator, typename std::decay_t< T >::size_type, typename std::decay_t< T >::reference > > | |
| Clua_check_impl::is_map< T, std::void_t< typename std::decay_t< T >::key_type, typename std::decay_t< T >::mapped_type > > | |
| Clua_check_impl::is_pair< T, std::void_t< typename std::decay_t< T >::first_type, typename std::decay_t< T >::second_type > > | |
| Cng::create_engine::type_list | |
| Cgui2::dialogs::mp_options_helper::type_node_data | |
| Cgui2::typed_formula< T > | Template class can hold a value or a formula to calculate the value |
| Cgui2::typed_formula< bool > | |
| Cgui2::typed_formula< color_t > | |
| Cgui2::typed_formula< int > | |
| Cgui2::typed_formula< PangoAlignment > | |
| Cgui2::typed_formula< std::string > | |
| Cgui2::typed_formula< t_string > | |
| Cgui2::typed_formula< unsigned > | |
| Chotkey::ui_command | Used as the main paramneter for can_execute_command/do_execute_command These functions are used to execute hotkeys but also to execute menu items, (Most menu items point to the same action as a hotkey but not all) |
| ►Cactions::undo_action_base | Records information to be able to undo an action |
| Cactions::undo::auto_shroud_action | |
| Cactions::undo::update_shroud_action | |
| ►Cactions::undo_action | Actions that are undoable (this does not include update_shroud and auto_shroud) |
| Cactions::undo::dismiss_action | |
| Cactions::undo::move_action | |
| Cactions::undo::recall_action | |
| Cactions::undo::recruit_action | |
| Cactions::undo_dummy_action | Entry for player actions that do not need any special code to be performed when undoing such as right-click menu items |
| Cactions::undo_event | |
| Cactions::undo_list | Class to store the actions that a player can undo and redo |
| Cunit_ability | Data typedef for unit_ability_list |
| Cunit_ability_list | |
| Cai::unit_advancements_aspect | |
| Cunit_alignments_defines | |
| Cunit_animation | |
| Cunit_animation_component | |
| Cunit_animator | |
| Cunit_creator | |
| Cunit::unit_ctor_t | |
| Cunit_drawer | |
| Cunit_experience_accelerator | |
| Cunit_filter | |
| Cunit_filter_impl::unit_filter_args | |
| ►Cunit_filter_impl::unit_filter_base | |
| Cunit_filter_impl::unit_filter_compound | |
| Cwfl::unit_formula_compare | |
| Cunit_formula_manager | |
| Cunit_frame | Describes a unit's animation sequence |
| Cn_unit::unit_id | |
| Cunit_map | Container associating units to locations |
| Cunit_movement_resetter | Object which temporarily resets a unit's movement |
| Cunit_display::unit_mover | A class to encapsulate the steps of drawing a unit's move |
| Cunit_map::unit_pod | The pointer to the unit and a reference counter to record the number of extant iteratorspointing to this unit |
| Cunit_race | |
| Cunit_type | A single unit type that the player may recruit |
| Cunit_type_data | |
| Cunit::upkeep_full | |
| Cunit::upkeep_loyal | |
| Cunit::upkeep_parser_visitor | Visitor helper class to parse the upkeep value from a config |
| Cunit::upkeep_type_visitor | Visitor helper struct to fetch the upkeep type flag if applicable, or the the value otherwise |
| Cunit::upkeep_value_visitor | Visitor helper class to fetch the appropriate upkeep value |
| ►Cmp_sync::user_choice | Interface for querying local choices |
| Cpersist_choice | |
| ►Cuser_handler | An interface class to handle nick registration To activate it put a [user_handler] section into the server configuration file |
| Cfuh | A class to handle the non-SQL logic for connecting to the phpbb forum database |
| Cmp::user_info | This class represents the information a client has about another player |
| Csdl::UserEvent | |
| Cucs4_convert_impl::utf16_impl | |
| Cucs4_convert_impl::utf32_impl | |
| Cucs4_convert_impl::utf8_impl | |
| Cimage::locator::value | |
| Cwb::variable_finalizer< T > | Finalizer class to help with exception safety sets variable to value on destruction |
| ►Cvariable_info< V > | Information on a WML variable |
| Cvariable_info_mutable< V > | Additional functionality for a non-const variable_info |
| Cvariable_info_implementation::variable_info_state< V > | |
| ►Cvariable_set | |
| Cconfig_variable_set | |
| Cgame_data | |
| Cutils::string_map_variable_set< T > | |
| Cwfl::variant | |
| Cwfl::variant_iterator | Iterator class for the variant |
| ►Cwfl::variant_value_base | Base class for all variant types |
| ►Cwfl::variant_container< variant_map_raw > | |
| Cwfl::variant_map | |
| ►Cwfl::variant_container< variant_vector > | |
| Cwfl::variant_list | |
| Cwfl::variant_callable | |
| Cwfl::variant_container< T > | Generalized implementation handling container variants |
| ►Cwfl::variant_numeric | Base class for numeric variant values |
| Cwfl::variant_decimal | |
| Cwfl::variant_int | |
| Cwfl::variant_string | |
| Cai::variant_value_translator< T > | |
| Cai::variant_value_translator< attacks_vector > | |
| Cai::variant_value_translator< bool > | |
| Cai::variant_value_translator< int > | |
| Cai::variant_value_translator< std::string > | |
| Cai::variant_value_translator< terrain_filter > | |
| Cvconfig | A variable-expanding proxy for the config class |
| ►Cstd::vector< T > | STL class |
| Cpathfind::paths::dest_vect | Ordered vector of possible destinations |
| Csecure_buffer | |
| Cversion_info | Represents version numbers |
| Cvariable_info_implementation::vi_policy_const | The variable_info policy classes |
| Cvariable_info_implementation::vi_policy_create | Creates a child table when resolving name if it doesn't exist yet |
| Cvariable_info_implementation::vi_policy_throw | Will throw an exception when trying to access a nonexistent table |
| Cgui2::dialogs::chat_log::view | |
| Cgui2::dialogs::gamestate_inspector::view | |
| Cgui2::dialogs::lua_interpreter::view | |
| Cgui2::viewport_implementation | Helper to implement private functions without modifying the header |
| Cdraw::viewport_setter | A class to manage automatic restoration of the viewport region |
| Chelp::help_menu::visible_item | Information about an item that is visible in the menu |
| ►Cgui2::iteration::policy::visit::visit_level< level > | This policy tries to visit the current level |
| Cgui2::iteration::policy::visit_level< true, level > | Specialized to select the visit::visit_level policy |
| Cgui2::iteration::policy::visit_level< bool, level > | Helper class to select to visit or skip a level |
| ►Cgui2::iteration::policy::visit_level< VC, walker_base::child > | |
| Cgui2::iteration::policy::order::bottom_up< VW, VG, VC > | |
| Cgui2::iteration::policy::order::top_down< VW, VG, VC > | |
| ►Cgui2::iteration::policy::visit_level< VG, walker_base::internal > | |
| Cgui2::iteration::policy::order::bottom_up< VW, VG, VC > | |
| Cgui2::iteration::policy::order::top_down< VW, VG, VC > | |
| ►Cgui2::iteration::policy::visit_level< VW, walker_base::self > | |
| Cgui2::iteration::policy::order::bottom_up< VW, VG, VC > | |
| Cgui2::iteration::policy::order::top_down< VW, VG, VC > | |
| ►Cwb::visitor | Abstract base class for all the visitors (cf GoF Visitor Design Pattern) the whiteboard uses |
| Cwb::highlighter::highlight_main_visitor | |
| Cwb::highlighter::highlight_secondary_visitor | |
| Cwb::highlighter::unhighlight_visitor | |
| Ct_string_base::walker | |
| ►Cgui2::iteration::walker_base | The walker abstract base class |
| Cgui2::iteration::container | A walker for a gui2::container_base |
| Cgui2::iteration::grid | A walker for a gui2::grid |
| Cgui2::iteration::scrollbar_container | A walker for a gui2::container_base |
| Cgui2::iteration::tree_node | A walker for a gui2::tree_view_node |
| Cgui2::iteration::walker::widget | A walker for a gui2::styled_widget |
| Cutils::wesnoth_epoch_defines | Reference points for the dates that define the storyline's calendar |
| Cwesnoth_global_fixture | |
| Cwesnothd_connection | A class that represents a TCP/IP connection to the wesnothd server |
| Cwidget_getter< widget_type, value_type > | |
| Cwidget_setter< widget_type, value_type > | |
| Csdl::window | The wrapper class for the SDL_Window class |
| Cgui2::window_implementation | Helper to implement private functions without modifying the header |
| Cgui2::builder_window::window_resolution | |
| Cwindows_battery_info | |
| Cwindows_tray_notification | |
| Cgame_events::wmi_manager | |
| Cgame_events::wml_action | |
| Cgame_events::wml_event_pump | |
| Chotkey::wml_hotkey_record | RAII helper class to control the lifetime of a WML hotkey_command |
| Cschema_validation::wml_key | Wml_key is used to save the information about one key |
| Cwml_loc | |
| Cgame_events::wml_menu_item | |
| Cgui2::dialogs::wml_message_input | Parameter pack for message text input options |
| Cgui2::dialogs::wml_message_option | Helper class for message options |
| Cgui2::dialogs::wml_message_options | Parameter pack for message list input options |
| Cgui2::dialogs::wml_message_portrait | Parameter pack for message portrait |
| ►Cschema_validation::wml_tag | Stores information about tag |
| Cschema_validation::wml_condition | Stores information about a conditional portion of a tag |
| ►Cschema_validation::wml_type | Stores information about a schema type |
| Cschema_validation::wml_type_alias | Stores information about a schema type |
| ►Cschema_validation::wml_type_composite | Stores information about a schema type |
| Cschema_validation::wml_type_intersection | Stores information about a schema type |
| ►Cschema_validation::wml_type_union | Stores information about a schema type |
| Cschema_validation::wml_type_list | Stores information about a schema type |
| Cschema_validation::wml_type_simple | Stores information about a schema type |
| Cschema_validation::wml_type_tstring | |
| ►Cxy_pred | |
| Cfilter_with_unit | |
| Cterrain_filter | |
| Cconfig_attribute_value::yes_no | A wrapper for bool to get the correct streaming ("yes"/"no") |
1.9.1