The Battle for Wesnoth  1.15.0-dev
editor_controller.cpp
Go to the documentation of this file.
1 /*
2  Copyright (C) 2008 - 2018 by Tomasz Sniatowski <kailoran@gmail.com>
3  Part of the Battle for Wesnoth Project http://www.wesnoth.org/
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or
8  (at your option) any later version.
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY.
11 
12  See the COPYING file for more details.
13 */
14 #define GETTEXT_DOMAIN "wesnoth-editor"
15 
17 
18 #include "editor/action/action.hpp"
22 
25 
27 
28 #include "preferences/editor.hpp"
29 
32 #include "gui/dialogs/message.hpp"
36 #include "gui/widgets/retval.hpp"
37 #include "wml_exception.hpp"
38 
39 #include "resources.hpp"
40 #include "reports.hpp"
41 
42 #include "cursor.hpp"
43 #include "desktop/clipboard.hpp"
44 #include "floating_label.hpp"
45 #include "help/help.hpp"
46 #include "preferences/game.hpp"
47 #include "gettext.hpp"
48 #include "image.hpp"
49 #include "preferences/display.hpp"
50 #include "sound.hpp"
51 #include "units/unit.hpp"
53 
54 #include "quit_confirmation.hpp"
55 
56 #include "utils/functional.hpp"
57 
58 namespace {
59 static std::vector<std::string> saved_windows_;
60 }
61 
62 namespace editor {
63 
65  : controller_base(game_config)
66  , mouse_handler_base()
67  , quit_confirmation(std::bind(&editor_controller::quit_confirm, this))
68  , active_menu_(editor::MAP)
69  , reports_(new reports())
70  , gui_(new editor_display(*this, controller_base::get_theme(game_config, "editor")))
71  , tods_()
72  , context_manager_(new context_manager(*gui_.get(), game_config_))
73  , toolkit_(nullptr)
74  , tooltip_manager_()
75  , floating_label_manager_(nullptr)
76  , do_quit_(false)
77  , quit_mode_(EXIT_ERROR)
78  , music_tracks_()
79 {
80  init_gui();
81  toolkit_.reset(new editor_toolkit(*gui_.get(), key_, game_config_, *context_manager_.get()));
82  context_manager_->locs_ = toolkit_->get_palette_manager()->location_palette_.get();
83  context_manager_->switch_context(0, true);
84  init_tods(game_config);
85  init_music(game_config);
88 
89  join();
90 }
91 
93 {
94  gui_->change_display_context(&get_current_map_context());
96  //gui_->add_redraw_observer(std::bind(&editor_controller::display_redraw_callback, this, _1));
101 // halo_manager_.reset(new halo::manager(*gui_));
102 // resources::halo = halo_manager_.get();
103 // ^ These lines no longer necessary, the gui owns its halo manager.
104 // TODO: Should the editor map contexts actually own the halo manager and swap them in and out from the gui?
105 // Note that if that is what happens it might not actually be a good idea for the gui to own the halo manager, so that it can be swapped out
106 // without deleting it.
107 }
108 
110 {
111  for (const config &schedule : game_config.child_range("editor_times")) {
112 
113  const std::string& schedule_id = schedule["id"];
114  const std::string& schedule_name = schedule["name"];
115  if (schedule_id.empty()) {
116  ERR_ED << "Missing ID attribute in a TOD Schedule." << std::endl;
117  continue;
118  }
119 
120  tods_map::iterator times = tods_.find(schedule_id);
121  if (times == tods_.end()) {
122  std::pair<tods_map::iterator, bool> new_times =
123  tods_.emplace(schedule_id, std::make_pair(schedule_name, std::vector<time_of_day>()));
124 
125  times = new_times.first;
126  } else {
127  ERR_ED << "Duplicate TOD Schedule identifiers." << std::endl;
128  continue;
129  }
130 
131  for (const config &time : schedule.child_range("time")) {
132  times->second.second.emplace_back(time);
133  }
134 
135  }
136 
137  if (tods_.empty()) {
138  ERR_ED << "No editor time-of-day defined" << std::endl;
139  }
140 }
141 
143 {
144  const std::string tag_name = "editor_music";
145  if (!game_config.has_child(tag_name))
146  ERR_ED << "No editor music defined" << std::endl;
147  else {
148  for (const config& editor_music : game_config.child_range(tag_name)) {
149  for (const config& music : editor_music.child_range("music")) {
150  sound::music_track track(music);
151  if (track.file_path().empty())
152  WRN_ED << "Music track " << track.id() << " not found." << std::endl;
153  else
154  music_tracks_.emplace_back(music);
155  }
156  }
157  }
158 }
159 
161 {
162  help::reset();
163 
164  resources::tod_manager = nullptr;
165  resources::filter_con = nullptr;
166 
167  resources::classification = nullptr;
168 }
169 
171 {
172  try {
173  while (!do_quit_) {
174  play_slice();
175  }
176  } catch (const editor_exception& e) {
177  gui2::show_transient_message(_("Fatal error"), e.what());
178  return EXIT_ERROR;
179  } catch (const wml_exception& e) {
180  e.show();
181  }
182  return quit_mode_;
183 }
184 
186 }
187 
188 void editor_controller::do_screenshot(const std::string& screenshot_filename /* = "map_screenshot.bmp" */)
189 {
190  try {
191  surface screenshot = gui().screenshot(true);
192  if(screenshot.null() || image::save_image(screenshot, screenshot_filename) != image::save_result::success) {
193  ERR_ED << "Screenshot creation failed!\n";
194  }
195  } catch (const wml_exception& e) {
196  e.show();
197  }
198 }
199 
201 {
202  std::string modified;
203  std::size_t amount = context_manager_->modified_maps(modified);
204 
205  std::string message;
206  if (amount == 0) {
207  message = _("Do you really want to quit?");
208  } else if (amount == 1 && get_current_map_context().modified()) {
209  message = _("Do you really want to quit? Changes to this map since the last save will be lost.");
210  } else {
211  message = _("Do you really want to quit? The following maps were modified and all changes since the last save will be lost:");
212  message += "\n" + modified;
213  }
214  return quit_confirmation::show_prompt(message);
215 }
216 
218 {
219  if (tods_.empty()) {
220  gui2::show_error_message(_("No editor time-of-day found."));
221  return;
222  }
223 
225 
226  if(gui2::dialogs::custom_tod::execute(manager.times(), manager.get_current_time())) {
227  // TODO save the new tod here
228  }
229 
230  gui_->update_tod();
231 
232  context_manager_->refresh_all();
233 }
234 
236 {
237  using namespace hotkey; //reduce hotkey:: clutter
238  switch (cmd.id) {
239  case HOTKEY_NULL:
240  if (index >= 0) {
241  unsigned i = static_cast<unsigned>(index);
242 
243  switch (active_menu_) {
244  case editor::MAP:
245  if (i < context_manager_->open_maps()) {
246  return true;
247  }
248  return false;
249  case editor::LOAD_MRU:
250  case editor::PALETTE:
251  case editor::AREA:
252  case editor::SIDE:
253  case editor::TIME:
254  case editor::SCHEDULE:
256  case editor::MUSIC:
257  case editor::LOCAL_TIME:
258  case editor::UNIT_FACING:
259  return true;
260  }
261  }
262  return false;
264  return true;
266  return toolkit_->get_palette_manager()->can_scroll_up();
268  return toolkit_->get_palette_manager()->can_scroll_down();
269  case HOTKEY_ZOOM_IN:
270  return !gui_->zoom_at_max();
271  case HOTKEY_ZOOM_OUT:
272  return !gui_->zoom_at_min();
273  case HOTKEY_ZOOM_DEFAULT:
274  case HOTKEY_FULLSCREEN:
275  case HOTKEY_SCREENSHOT:
277  case HOTKEY_TOGGLE_GRID:
278  case HOTKEY_MOUSE_SCROLL:
279  case HOTKEY_ANIMATE_MAP:
280  case HOTKEY_MUTE:
281  case HOTKEY_PREFERENCES:
282  case HOTKEY_HELP:
283  case HOTKEY_QUIT_GAME:
284  case HOTKEY_SCROLL_UP:
285  case HOTKEY_SCROLL_DOWN:
286  case HOTKEY_SCROLL_LEFT:
287  case HOTKEY_SCROLL_RIGHT:
288  return true; //general hotkeys we can always do
289 
291  return !get_current_map_context().units().empty();
292 
293  case HOTKEY_STATUS_TABLE:
294  return !get_current_map_context().teams().empty();
295 
297  return gui().mouseover_hex().valid();
298 
299  // unit tool related
300  case HOTKEY_DELETE_UNIT:
301  case HOTKEY_RENAME_UNIT:
309  {
310  map_location loc = gui_->mouseover_hex();
311  const unit_map& units = get_current_map_context().units();
312  return (toolkit_->is_mouse_action_set(HOTKEY_EDITOR_TOOL_UNIT) &&
313  units.find(loc) != units.end());
314  }
315  case HOTKEY_UNDO:
317  case HOTKEY_REDO:
329  return true;
330 
334 
337  return !get_current_map_context().teams().empty();
338 
339  // brushes
347 
349  return true;
351  return toolkit_->get_palette_manager()->active_palette().supports_swap();
355  {
356  std::string dummy;
357  return context_manager_->modified_maps(dummy) > 1;
358  }
364  return true;
366  return !get_current_map_context().get_filename().empty()
368 
369  // Tools
370  // Pure map editing tools this can be used all the time.
375  return true;
376  // WWL dependent tools which don't rely on defined sides.
383  return !get_current_map_context().teams().empty();
384 
388  return !get_current_map_context().is_pure_map() &&
390 
392  return !get_current_map_context().is_pure_map() &&
394  && !get_current_map_context().map().selection().empty();
395 
400  return !get_current_map_context().map().selection().empty()
401  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
403  return (get_current_map_context().map().selection().size() > 1
404  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE));
408  return false; //not implemented
410  return !context_manager_->clipboard_empty();
415  return !context_manager_->clipboard_empty()
416  && toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
419  return !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
421  return !get_current_map_context().map().selection().empty()
423  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
440  return true;
442  return false; //not implemented
446  return true;
447  default:
448  return false;
449  }
450 }
451 
453  using namespace hotkey;
454  switch (command) {
455 
457  {
459  get_current_map_context().units().find(gui_->mouseover_hex());
460  return un->loyal() ? ACTION_ON : ACTION_OFF;
461 
462  }
464  {
466  get_current_map_context().units().find(gui_->mouseover_hex());
467  return un->can_recruit() ? ACTION_ON : ACTION_OFF;
468  }
470  {
472  get_current_map_context().units().find(gui_->mouseover_hex());
473  return (!un->unrenamable()) ? ACTION_ON : ACTION_OFF;
474  }
475  //TODO remove hardcoded hotkey names
477  return context_manager_->is_active_transitions_hotkey("editor-auto-update-transitions")
480  return context_manager_->is_active_transitions_hotkey("editor-partial-update-transitions")
483  return context_manager_->is_active_transitions_hotkey("editor-no-update-transitions")
486  return toolkit_->is_active_brush("brush-1") ? ACTION_ON : ACTION_OFF;
488  return toolkit_->is_active_brush("brush-2") ? ACTION_ON : ACTION_OFF;
490  return toolkit_->is_active_brush("brush-3") ? ACTION_ON : ACTION_OFF;
492  return toolkit_->is_active_brush("brush-nw-se") ? ACTION_ON : ACTION_OFF;
494  return toolkit_->is_active_brush("brush-sw-ne") ? ACTION_ON : ACTION_OFF;
495 
496  case HOTKEY_TOGGLE_GRID:
502  return get_current_map_context().map().selection().empty() ?
513  return toolkit_->is_mouse_action_set(command) ? ACTION_ON : ACTION_OFF;
515  return gui_->get_draw_coordinates() ? ACTION_ON : ACTION_OFF;
517  return gui_->get_draw_terrain_codes() ? ACTION_ON : ACTION_OFF;
519  return gui_->get_draw_num_of_bitmaps() ? ACTION_ON : ACTION_OFF;
520 
531  case HOTKEY_ZOOM_DEFAULT:
532  return (gui_->get_zoom_factor() == 1.0) ? hotkey::ACTION_ON : hotkey::ACTION_OFF;
533 
534  case HOTKEY_NULL:
535  switch (active_menu_) {
536  case editor::MAP:
537  return index == context_manager_->current_context_index()
539  case editor::LOAD_MRU:
540  return ACTION_STATELESS;
541  case editor::PALETTE:
542  return ACTION_STATELESS;
543  case editor::AREA:
544  return index == get_current_map_context().get_active_area()
546  case editor::SIDE:
547  return static_cast<std::size_t>(index) == gui_->playing_team()
549  case editor::TIME:
552  case editor::LOCAL_TIME:
554  get_current_map_context().get_active_area())
556  case editor::MUSIC:
558  ? ACTION_ON : ACTION_OFF;
559  case editor::SCHEDULE:
560  {
561  tods_map::const_iterator it = tods_.begin();
562  std::advance(it, index);
563  const std::vector<time_of_day>& times1 = it->second.second;
564  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times();
565  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
566  }
568  {
569  tods_map::const_iterator it = tods_.begin();
570  std::advance(it, index);
571  const std::vector<time_of_day>& times1 = it->second.second;
572  int active_area = get_current_map_context().get_active_area();
573  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times(active_area);
574  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
575  }
576  case editor::UNIT_FACING:
577  {
579  assert(un != get_current_map_context().units().end());
580  return un->facing() == index ? ACTION_SELECTED : ACTION_DESELECTED;
581  }
582  }
583  return ACTION_ON;
584  default:
585  return command_executor::get_action_state(command, index);
586  }
587 }
588 
589 bool editor_controller::do_execute_command(const hotkey::hotkey_command& cmd, int index, bool press, bool release)
590 {
591  hotkey::HOTKEY_COMMAND command = cmd.id;
592  SCOPE_ED;
593  using namespace hotkey;
594 
595  // nothing here handles release; fall through to base implementation
596  if (!press) {
597  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
598  }
599 
600  switch (command) {
601  case HOTKEY_NULL:
602  switch (active_menu_) {
603  case MAP:
604  if (index >= 0) {
605  unsigned i = static_cast<unsigned>(index);
606  if (i < context_manager_->size()) {
607  context_manager_->switch_context(index);
608  toolkit_->hotkey_set_mouse_action(HOTKEY_EDITOR_TOOL_PAINT);
609  return true;
610  }
611  }
612  return false;
613  case LOAD_MRU:
614  if (index >= 0) {
615  context_manager_->load_mru_item(static_cast<unsigned>(index));
616  }
617  return true;
618  case PALETTE:
619  toolkit_->get_palette_manager()->set_group(index);
620  return true;
621  case SIDE:
622  gui_->set_team(index, true);
623  gui_->set_playing_team(index);
624  toolkit_->get_palette_manager()->draw_contents();
625  return true;
626  case AREA:
627  {
629  const std::set<map_location>& area =
631  std::vector<map_location> locs(area.begin(), area.end());
633  gui_->scroll_to_tiles(locs.begin(), locs.end());
634  return true;
635  }
636  case TIME:
637  {
639  gui_->update_tod();
640  return true;
641  }
642  case LOCAL_TIME:
643  {
645  return true;
646  }
647  case MUSIC:
648  {
649  //TODO mark the map as changed
652 #if 0
653  std::vector<config> items;
654  items.emplace_back("id", "editor-playlist");
655  std::shared_ptr<gui::button> b = gui_->find_menu_button("menu-playlist");
656  show_menu(items, b->location().x +1, b->location().y + b->height() +1, false, *gui_);
657 #endif
658  return true;
659  }
660  case SCHEDULE:
661  {
662  tods_map::iterator iter = tods_.begin();
663  std::advance(iter, index);
664  get_current_map_context().replace_schedule(iter->second.second);
665  // TODO: test again after the assign-schedule menu is fixed. Should work, though.
666  gui_->update_tod();
667  return true;
668  }
669  case LOCAL_SCHEDULE:
670  {
671  tods_map::iterator iter = tods_.begin();
672  std::advance(iter, index);
673  get_current_map_context().replace_local_schedule(iter->second.second);
674  return true;
675  }
676  case UNIT_FACING:
677  {
679  assert(un != get_current_map_context().units().end());
680  un->set_facing(map_location::DIRECTION(index));
681  un->anim_comp().set_standing();
682  return true;
683  }
684  }
685  return true;
686 
687  //Zoom
688  case HOTKEY_ZOOM_IN:
689  gui_->set_zoom(true);
691  toolkit_->set_mouseover_overlay(*gui_);
692  return true;
693  case HOTKEY_ZOOM_OUT:
694  gui_->set_zoom(false);
696  toolkit_->set_mouseover_overlay(*gui_);
697  return true;
698  case HOTKEY_ZOOM_DEFAULT:
699  gui_->set_default_zoom();
701  toolkit_->set_mouseover_overlay(*gui_);
702  return true;
703 
704  //Palette
706  {
707  //TODO this code waits for the gui2 dialog to get ready
708 // std::vector< std::pair< std::string, std::string >> blah_items;
709 // toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(blah_items);
710 // int selected = 1; //toolkit_->get_palette_manager()->active_palette().get_selected;
711 // gui2::teditor_select_palette_group::execute(selected, blah_items, gui_->video());
712  }
713  return true;
715  toolkit_->get_palette_manager()->scroll_up();
716  return true;
718  toolkit_->get_palette_manager()->scroll_down();
719  return true;
720 
721  case HOTKEY_QUIT_GAME:
723  do_quit_ = true;
725  }
726  return true;
729  return true;
731  context_manager_->save_all_maps(true);
732  do_quit_ = true;
734  return true;
737  return true;
739  toolkit_->get_palette_manager()->active_palette().swap();
740  return true;
742  if (dynamic_cast<const editor_action_chain*>(get_current_map_context().last_undo_action()) != nullptr) {
744  context_manager_->refresh_after_action();
745  } else {
746  undo();
747  }
748  return true;
749 
750  //Tool Selection
759  toolkit_->hotkey_set_mouse_action(command);
760  return true;
761 
763  add_area();
764  return true;
765 
767  change_unit_id();
768  return true;
769 
771  {
772  map_location loc = gui_->mouseover_hex();
774  const std::set<std::string>& recruit_set = toolkit_->get_palette_manager()->unit_palette_->get_selected_bg_items();
775  std::vector<std::string> recruits(recruit_set.begin(), recruit_set.end());
776  un->set_recruits(recruits);
777  }
778  return true;
780  {
781  map_location loc = gui_->mouseover_hex();
783  bool unrenamable = un->unrenamable();
784  un->set_unrenamable(!unrenamable);
785  }
786  return true;
788  {
789  map_location loc = gui_->mouseover_hex();
791  bool canrecruit = un->can_recruit();
792  un->set_can_recruit(!canrecruit);
793  un->anim_comp().set_standing();
794  }
795  return true;
796  case HOTKEY_DELETE_UNIT:
797  {
798  map_location loc = gui_->mouseover_hex();
800  }
801  return true;
802  case HOTKEY_EDITOR_CLIPBOARD_PASTE: //paste is somewhat different as it might be "one action then revert to previous mode"
803  toolkit_->hotkey_set_mouse_action(command);
804  return true;
805 
806  //Clipboard
808  context_manager_->get_clipboard().rotate_60_cw();
809  toolkit_->update_mouse_action_highlights();
810  return true;
812  context_manager_->get_clipboard().rotate_60_ccw();
813  toolkit_->update_mouse_action_highlights();
814  return true;
816  context_manager_->get_clipboard().flip_horizontal();
817  toolkit_->update_mouse_action_highlights();
818  return true;
820  context_manager_->get_clipboard().flip_vertical();
821  toolkit_->update_mouse_action_highlights();
822  return true;
823 
824  //Brushes
826  toolkit_->cycle_brush();
827  return true;
829  toolkit_->set_brush("brush-1");
830  return true;
832  toolkit_->set_brush("brush-2");
833  return true;
835  toolkit_->set_brush("brush-3");
836  return true;
838  toolkit_->set_brush("brush-nw-se");
839  return true;
841  toolkit_->set_brush("brush-sw-ne");
842  return true;
843 
845  copy_selection();
846  return true;
848  cut_selection();
849  return true;
851  context_manager_->rename_area_dialog();
852  return true;
854  save_area();
855  return true;
858  return true;
860  if(!get_current_map_context().map().everything_selected()) {
861  context_manager_->perform_refresh(editor_action_select_all());
862  return true;
863  }
864  FALLTHROUGH;
867  return true;
869  context_manager_->perform_refresh(editor_action_select_none());
870  return true;
872  context_manager_->fill_selection();
873  return true;
876  get_current_map_context().map().selection()));
877  return true;
878 
880  context_manager_->edit_scenario_dialog();
881  return true;
882 
885  get_current_map_context().get_active_area());
886  return true;
887 
888  // map specific
890  context_manager_->close_current_context();
891  return true;
893  context_manager_->load_map_dialog();
894  return true;
896  context_manager_->revert_map();
897  return true;
899  context_manager_->new_map_dialog();
900  return true;
902  context_manager_->new_scenario_dialog();
903  return true;
905  save_map();
906  return true;
908  context_manager_->save_all_maps();
909  return true;
911  context_manager_->save_map_as_dialog();
912  return true;
914  context_manager_->save_scenario_as_dialog();
915  return true;
917  context_manager_->generate_map_dialog();
918  return true;
920  context_manager_->apply_mask_dialog();
921  return true;
923  context_manager_->create_mask_to_dialog();
924  return true;
926  context_manager_->resize_map_dialog();
927  return true;
928 
929  // Side specific ones
931  if(get_current_map_context().teams().size() >= 9) {
932  size_t new_side_num = get_current_map_context().teams().size() + 1;
933  toolkit_->get_palette_manager()->location_palette_->add_item(std::to_string(new_side_num));
934  }
936  gui_->init_flags();
937  return true;
939  gui_->set_team(0, true);
940  gui_->set_playing_team(0);
942  return true;
944  context_manager_->edit_side_dialog(gui_->viewing_team());
945  return true;
946 
947  // Transitions
949  context_manager_->set_update_transitions_mode(2);
950  return true;
952  context_manager_->set_update_transitions_mode(1);
953  return true;
955  context_manager_->set_update_transitions_mode(0);
956  return true;
958  if(context_manager_->toggle_update_transitions()) {
959  return true;
960  }
961  FALLTHROUGH;
963  context_manager_->refresh_all();
964  return true;
965  // Refresh
967  context_manager_->reload_map();
968  return true;
971  return true;
972 
974  gui().set_draw_coordinates(!gui().get_draw_coordinates());
975  preferences::editor::set_draw_hex_coordinates(gui().get_draw_coordinates());
976  return true;
978  gui().set_draw_terrain_codes(!gui().get_draw_terrain_codes());
979  preferences::editor::set_draw_terrain_codes(gui().get_draw_terrain_codes());
980  return true;
982  gui().set_draw_num_of_bitmaps(!gui().get_draw_num_of_bitmaps());
983  preferences::editor::set_draw_num_of_bitmaps(gui().get_draw_num_of_bitmaps());
984  return true;
986  location_palette* lp = dynamic_cast<location_palette*>(&toolkit_->get_palette_manager()->active_palette());
987  if (lp) {
989  // No idea if this is the right thing to call, but it ensures starting
990  // position labels get removed on delete.
991  context_manager_->refresh_after_action();
992  }
993  return true;
994  }
995  default:
996  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
997  }
998 }
999 
1001 {
1002  help::show_help("..editor");
1003 }
1004 
1005 void editor_controller::show_menu(const std::vector<config>& items_arg, int xloc, int yloc, bool context_menu, display& disp)
1006 {
1007  if(context_menu) {
1008  if(!get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(xloc, yloc))) {
1009  return;
1010  }
1011  }
1012 
1013  std::vector<config> items;
1014  for(const auto& c : items_arg) {
1015  const std::string& id = c["id"];
1017 
1018  if((can_execute_command(command) && (!context_menu || in_context_menu(command.id)))
1019  || command.id == hotkey::HOTKEY_NULL)
1020  {
1021  items.emplace_back("id", id);
1022  }
1023  }
1024 
1025  // No point in showing an empty menu.
1026  if(items.empty()) {
1027  return;
1028  }
1029 
1030  // Based on the ID of the first entry, we fill the menu contextually.
1031  const std::string& first_id = items.front()["id"];
1032 
1033  if(first_id == "EDITOR-LOAD-MRU-PLACEHOLDER") {
1035  context_manager_->expand_load_mru_menu(items, 0);
1036  }
1037 
1038  if(first_id == "editor-switch-map") {
1040  context_manager_->expand_open_maps_menu(items, 0);
1041  }
1042 
1043  if(first_id == "editor-palette-groups") {
1045  toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(items, 0);
1046  }
1047 
1048  if(first_id == "editor-switch-side") {
1050  context_manager_->expand_sides_menu(items, 0);
1051  }
1052 
1053  if(first_id == "editor-switch-area") {
1055  context_manager_->expand_areas_menu(items, 0);
1056  }
1057 
1058  if(!items.empty() && items.front()["id"] == "editor-switch-time") {
1060  context_manager_->expand_time_menu(items, 0);
1061  }
1062 
1063  if(first_id == "editor-assign-local-time") {
1065  context_manager_->expand_local_time_menu(items, 0);
1066  }
1067 
1068  if(first_id == "menu-unit-facings") {
1070  auto pos = items.erase(items.begin());
1071  int dir = 0;
1072  std::generate_n(std::inserter<std::vector<config>>(items, pos), static_cast<int>(map_location::NDIRECTIONS), [&dir]() -> config {
1074  });
1075  }
1076 
1077  if(first_id == "editor-playlist") {
1079  auto pos = items.erase(items.begin());
1080  std::transform(music_tracks_.begin(), music_tracks_.end(), std::inserter<std::vector<config>>(items, pos), [](const sound::music_track& track) -> config {
1081  return config {"label", track.title().empty() ? track.id() : track.title()};
1082  });
1083  }
1084 
1085  if(first_id == "editor-assign-schedule") {
1087  auto pos = items.erase(items.begin());
1088  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1089  return config {"label", tod.second.first};
1090  });
1091  }
1092 
1093  if(first_id == "editor-assign-local-schedule") {
1095  auto pos = items.erase(items.begin());
1096  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1097  return config {"label", tod.second.first};
1098  });
1099  }
1100 
1101  command_executor::show_menu(items, xloc, yloc, context_menu, disp);
1102 }
1103 
1105 {
1107 }
1108 
1110 {
1112 }
1113 
1115 {
1116  map_location loc = gui_->mouseover_hex();
1117  const unit_map & units = get_current_map_context().units();
1118  const unit_map::const_unit_iterator un = units.find(loc);
1119  if(un != units.end()) {
1120  help::show_unit_help(un->type_id(), un->type().show_variations_in_help(), false);
1121  } else {
1122  help::show_help("..units");
1123  }
1124 }
1125 
1126 
1128 {
1129  if (!get_current_map_context().map().selection().empty()) {
1130  context_manager_->get_clipboard() = map_fragment(get_current_map_context().map(), get_current_map_context().map().selection());
1131  context_manager_->get_clipboard().center_by_mass();
1132  }
1133 }
1134 
1136 {
1137  map_location loc = gui_->mouseover_hex();
1138  unit_map& units = get_current_map_context().units();
1139  const unit_map::unit_iterator& un = units.find(loc);
1140 
1141  const std::string title(N_("Change Unit ID"));
1142  const std::string label(N_("ID:"));
1143 
1144  if(un != units.end()) {
1145  std::string id = un->id();
1146  if (gui2::dialogs::edit_text::execute(title, label, id)) {
1147  un->set_id(id);
1148  }
1149  }
1150 }
1151 
1153 {
1154  map_location loc = gui_->mouseover_hex();
1155  unit_map& units = get_current_map_context().units();
1156  const unit_map::unit_iterator& un = units.find(loc);
1157 
1158  const std::string title(N_("Rename Unit"));
1159  const std::string label(N_("Name:"));
1160 
1161  if(un != units.end()) {
1162  std::string name = un->name();
1163  if(gui2::dialogs::edit_text::execute(title, label, name)) {
1164  //TODO we may not want a translated name here.
1165  un->set_name(name);
1166  }
1167  }
1168 }
1169 
1171 {
1173 }
1174 
1176 {
1177  copy_selection();
1179 }
1180 
1182 {
1183  const std::set<map_location>& area = get_current_map_context().map().selection();
1185 }
1186 
1188 {
1189  const std::set<map_location>& area = get_current_map_context().map().selection();
1191 }
1192 
1194 {
1195  std::stringstream ssx, ssy;
1196  std::set<map_location>::const_iterator i = get_current_map_context().map().selection().begin();
1197  if (i != get_current_map_context().map().selection().end()) {
1198  ssx << "x = " << i->wml_x();
1199  ssy << "y = " << i->wml_y();
1200  ++i;
1201  while (i != get_current_map_context().map().selection().end()) {
1202  ssx << ", " << i->wml_x();
1203  ssy << ", " << i->wml_y();
1204  ++i;
1205  }
1206  ssx << "\n" << ssy.str() << "\n";
1207  desktop::clipboard::copy_to_clipboard(ssx.str(), false);
1208  }
1209 }
1210 
1212 {
1213  if (action) {
1214  const editor_action_ptr action_auto(action);
1216  }
1217 }
1218 
1219 void editor_controller::perform_refresh_delete(editor_action* action, bool drag_part /* =false */)
1220 {
1221  if (action) {
1222  const editor_action_ptr action_auto(action);
1223  context_manager_->perform_refresh(*action, drag_part);
1224  }
1225 }
1226 
1228 {
1230  context_manager_->refresh_all();
1231 }
1232 
1234 {
1235  toolkit_->adjust_size();
1236  toolkit_->get_palette_manager()->draw_contents();
1238 }
1239 
1241 {
1243  context_manager_->refresh_after_action();
1244 }
1245 
1247 {
1249  context_manager_->refresh_after_action();
1250 }
1251 
1252 void editor_controller::mouse_motion(int x, int y, const bool /*browse*/,
1253  bool update, map_location /*new_loc*/)
1254 {
1255  if (mouse_handler_base::mouse_motion_default(x, y, update)) return;
1256  map_location hex_clicked = gui().hex_clicked_on(x, y);
1257  if (get_current_map_context().map().on_board_with_border(drag_from_hex_) && is_dragging()) {
1258  editor_action* a = nullptr;
1259  bool partial = false;
1261  if (dragging_left_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(1)) != 0) {
1262  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1263  a = get_mouse_action().drag_left(*gui_, x, y, partial, last_undo);
1264  } else if (dragging_right_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(3)) != 0) {
1265  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1266  a = get_mouse_action().drag_right(*gui_, x, y, partial, last_undo);
1267  }
1268  //Partial means that the mouse action has modified the
1269  //last undo action and the controller shouldn't add
1270  //anything to the undo stack (hence a different perform_ call)
1271  if (a != nullptr) {
1272  const editor_action_ptr aa(a);
1273  if (partial) {
1275  } else {
1277  }
1278  context_manager_->refresh_after_action(true);
1279  }
1280  } else {
1281  get_mouse_action().move(*gui_, hex_clicked);
1282  }
1283  gui().highlight_hex(hex_clicked);
1284 }
1285 
1287 {
1288  return get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(x,y));
1289 }
1290 
1291 bool editor_controller::right_click_show_menu(int /*x*/, int /*y*/, const bool /*browse*/)
1292 {
1294 }
1295 
1296 bool editor_controller::left_click(int x, int y, const bool browse)
1297 {
1298  toolkit_->clear_mouseover_overlay();
1299  if (mouse_handler_base::left_click(x, y, browse))
1300  return true;
1301 
1302  LOG_ED << "Left click, after generic handling\n";
1303  map_location hex_clicked = gui().hex_clicked_on(x, y);
1304  if (!get_current_map_context().map().on_board_with_border(hex_clicked))
1305  return true;
1306 
1307  LOG_ED << "Left click action " << hex_clicked << "\n";
1309  perform_refresh_delete(a, true);
1310 
1311  return false;
1312 }
1313 
1314 void editor_controller::left_drag_end(int x, int y, const bool /*browse*/)
1315 {
1317  perform_delete(a);
1318 }
1319 
1320 void editor_controller::left_mouse_up(int x, int y, const bool /*browse*/)
1321 {
1323  perform_delete(a);
1324  toolkit_->set_mouseover_overlay();
1325  context_manager_->refresh_after_action();
1326 }
1327 
1328 bool editor_controller::right_click(int x, int y, const bool browse)
1329 {
1330  toolkit_->clear_mouseover_overlay();
1331  if (mouse_handler_base::right_click(x, y, browse)) return true;
1332  LOG_ED << "Right click, after generic handling\n";
1333  map_location hex_clicked = gui().hex_clicked_on(x, y);
1334  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return true;
1335  LOG_ED << "Right click action " << hex_clicked << "\n";
1337  perform_refresh_delete(a, true);
1338  return false;
1339 }
1340 
1341 void editor_controller::right_drag_end(int x, int y, const bool /*browse*/)
1342 {
1344  perform_delete(a);
1345 }
1346 
1347 void editor_controller::right_mouse_up(int x, int y, const bool browse)
1348 {
1349  // Call base method to handle context menus.
1350  mouse_handler_base::right_mouse_up(x, y, browse);
1351 
1353  perform_delete(a);
1354  toolkit_->set_mouseover_overlay();
1355  context_manager_->refresh_after_action();
1356 }
1357 
1359 {
1360  const map_location& loc = gui().mouseover_hex();
1361  if (get_current_map_context().map().on_board(loc) == false)
1362  return;
1363 
1366 }
1367 
1368 void editor_controller::process_keyup_event(const SDL_Event& event)
1369 {
1370  editor_action* a = get_mouse_action().key_event(gui(), event);
1372  toolkit_->set_mouseover_overlay();
1373 }
1374 
1376  return this;
1377 }
1378 
1380 {
1382 }
1383 
1385 {
1387 }
1388 
1390 {
1392 }
1393 
1395 {
1397 }
1398 
1400 {
1401  return toolkit_->get_palette_manager()->active_palette().action_pressed();
1402 }
1403 
1404 } //end namespace editor
virtual bool in_context_menu(hotkey::HOTKEY_COMMAND command) const
void perform_refresh_delete(editor_action *action, bool drag_part=false)
Peform an action on the current map_context, then refresh the display and delete the pointer...
const map_location & mouseover_hex() const
Definition: display.hpp:358
Randomize terrain in an area.
Definition: action.hpp:441
void undo()
Un-does the last action, and puts it in the redo stack for a possible redo.
void set_grid(bool ison)
Definition: display.cpp:70
virtual editor_action * click_left(editor_display &disp, int x, int y)=0
A click, possibly the beginning of a drag.
void set_scroll_up(bool on)
void set_preference_display_settings()
Definition: display.cpp:44
::tod_manager * tod_manager
Definition: resources.cpp:29
void copy_selection()
Copy the selection on the current map to the clipboard.
static std::string write_translated_direction(DIRECTION dir)
Definition: location.cpp:160
void set_draw_num_of_bitmaps(bool value)
Setter for the terrain code debug overlay on tiles.
Definition: display.hpp:431
void set_scroll_down(bool on)
unit_iterator end()
Definition: map.hpp:415
bool minimap_draw_units()
Definition: general.cpp:787
A map fragment – a collection of locations and information abut them.
void add_to_playlist(const sound::music_track &track)
const std::string & id() const
Select the entire map.
std::unique_ptr< font::floating_label_context > floating_label_manager_
HOTKEY_COMMAND id
the names are strange: the "hotkey::HOTKEY_COMMAND" is named id, and the string to identify the objec...
const t_translation::terrain_code & get_selected_bg_terrain()
bool dragging_right_
RMB drag init flag.
void set_draw_terrain_codes(bool value)
Setter for the terrain code debug overlay on tiles.
Definition: display.hpp:419
void set(CURSOR_TYPE type)
Use the default parameter to reset cursors.
Definition: cursor.cpp:173
void save_map() override
Save the map, open dialog if not named yet.
void export_selection_coords()
Export the WML-compatible list of selected tiles to the system clipboard.
int dummy
Definition: lstrlib.cpp:1125
std::unique_ptr< editor_action > editor_action_ptr
Action pointer typedef.
game_classification * classification
Definition: resources.cpp:34
void show_terrain_description(const terrain_type &t)
Definition: help.cpp:89
void do_screenshot(const std::string &screenshot_filename="map_screenshot.bmp")
Takes a screenshot.
void mouse_motion(int x, int y, const bool browse, bool update, map_location new_loc=map_location::null_location()) override
Called when a mouse motion event takes place.
const map_location hex_clicked_on(int x, int y) const
given x,y co-ordinates of an onscreen pixel, will return the location of the hex that this pixel corr...
Definition: display.cpp:488
bool quit_confirm()
Show a quit confirmation dialog and returns true if the user pressed &#39;yes&#39;.
static help_manager manager
The help manager.
Definition: help.cpp:34
bool draw_num_of_bitmaps()
Definition: editor.cpp:52
Editor action classes.
void save_area(const std::set< map_location > &area)
Definition: map_context.hpp:98
Add a special kind of assert to validate whether the input from WML doesn&#39;t contain any problems that...
void new_side()
Adds a new side to the map.
std::unique_ptr< editor_toolkit > toolkit_
void custom_tods_dialog()
Display the settings dialog, used to control e.g.
void process_keyup_event(const SDL_Event &event) override
Process keyup (always).
void left_drag_end(int x, int y, const bool browse) override
Called whenever the left mouse drag has "ended".
#define a
void reset()
Flags the help manager&#39;s contents for regeneration.
Definition: help.cpp:41
bool has_child(config_key_type key) const
Determine whether a config has a child or not.
Definition: config.cpp:416
bool minimap_movement_coding()
Definition: general.cpp:767
const std::string & get_filename() const
editor_display & gui() override
Reference to the used display objects.
bool can_execute_command(const hotkey::hotkey_command &command, int index=-1) const override
command_executor override
child_itors child_range(config_key_type key)
Definition: config.cpp:366
void new_area(const std::set< map_location > &area)
void show_unit_list(display &gui)
Definition: unit_list.cpp:195
bool right_click_show_menu(int x, int y, const bool browse) override
Called in the default right_click when the context menu is about to be shown, can be used for preproc...
void set_active_area(int index)
int get_current_time(const map_location &loc=map_location::null_location()) const
map_labels & get_labels()
#define LOG_ED
void save_area()
Save the current selection to the active area.
void preferences() override
Show the preferences dialog.
static bool show_prompt(const std::string &message)
Stores all information related to functions that can be bound to hotkeys.
save_result save_image(const locator &i_locator, const std::string &filename)
Definition: image.cpp:1257
const mouse_action & get_mouse_action() const
Get the current mouse action.
const terrain_type & get_terrain_info(const t_translation::terrain_code &terrain) const
Definition: map.cpp:96
void add_area()
Add a new area to the current context, filled with the selection if any.
virtual void play_slice(bool is_delay_enabled=true)
STL namespace.
void redo()
Re-does a previously undid action, and puts it back in the undo stack.
virtual editor_action * drag_left(editor_display &disp, int x, int y, bool &partial, editor_action *last_undo)
Drag operation.
#define SCOPE_ED
const std::vector< std::string > items
void play_music_once(const std::string &file)
Definition: sound.cpp:565
The editor_controller class contains the mouse and keyboard event handling routines for the editor...
bool draw_terrain_codes()
Definition: editor.cpp:36
Set starting position action.
Definition: action.hpp:340
void partial_undo()
Un-does a single step from a undo action chain.
Keyboard shortcuts for game actions.
void show_unit_help(const std::string &show_topic, bool has_variations, bool hidden)
Open the help browser, show unit with id unit_id.
Definition: help.cpp:79
bool null() const
Definition: surface.hpp:79
Unit and team statistics.
void remove_area(int index)
void flush_cache()
Definition: image.cpp:250
bool modified() const
#define b
#define WRN_ED
bool minimap_draw_villages()
Definition: general.cpp:797
void show() const
Shows the error in a dialog.
const std::unique_ptr< editor_display > gui_
The display object used and owned by the editor.
void show_menu(const std::vector< config > &items_arg, int xloc, int yloc, bool context_menu, display &disp) override
controller_base override
bool do_execute_command(const hotkey::hotkey_command &command, int index=-1, bool press=true, bool release=false) override
command_executor override
map_context & get_current_map_context() const
void right_mouse_up(int x, int y, const bool browse) override
Called when the right mouse button is up.
static UNUSEDNOWARN std::string _(const char *str)
Definition: gettext.hpp:89
virtual editor_action * up_left(editor_display &disp, int x, int y)
void right_drag_end(int x, int y, const bool browse) override
Called whenever the right mouse drag has "ended".
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:86
void set_local_starting_time(int time)
TODO.
virtual editor_action * key_event(editor_display &disp, const SDL_Event &e)
Function called by the controller on a key event for the current mouse action.
const std::set< map_location > & selection() const
Return the selection set.
Definition: editor_map.hpp:149
surface screenshot(bool map_screenshot=false)
Capture a (map-)screenshot into a surface.
Definition: display.cpp:660
void init_tods(const config &game_config)
init the available time-of-day settings
virtual bool has_context_menu() const
bool on_board_with_border(const map_location &loc) const
Definition: map.cpp:372
void remove_side()
removes the last side from the scenario
Definition: map_context.hpp:93
Implements a quit confirmation dialog.
virtual editor_action * drag_right(editor_display &disp, int x, int y, bool &partial, editor_action *last_undo)
Drag operation.
filter_context * filter_con
Definition: resources.cpp:23
void show_transient_message(const std::string &title, const std::string &message, const std::string &image, const bool message_use_markup, const bool title_use_markup)
Shows a transient message to the user.
bool valid() const
Definition: location.hpp:93
void set_draw_coordinates(bool value)
Setter for the x,y debug overlay on tiles.
Definition: display.hpp:407
void undo() override
Undos an action in the current map context.
virtual hotkey::command_executor * get_hotkey_command_executor() override
Optionally get a command executor to handle context menu events.
map_location drag_from_hex_
Drag start map location.
void replace_schedule(const std::vector< time_of_day > &schedule)
virtual editor_action * click_right(editor_display &disp, int x, int y)=0
A click, possibly the beginning of a drag.
Editor action classes.
void set_starting_time(int time)
TODO.
virtual void join()
Definition: events.cpp:253
int show_menu(lua_State *L)
Displays a popup menu at the current mouse position Best used from a [set_menu_item], to show a submenu.
Definition: lua_gui2.cpp:399
editor_action * last_undo_action()
bool is_pure_map() const
bool draw_hex_coordinates()
Definition: editor.cpp:44
virtual editor_action * up_right(editor_display &disp, int x, int y)
void refresh_image_cache()
Reload images.
Manage the empty-palette in the editor.
Definition: action.cpp:29
void perform_action(const editor_action &action)
Performs an action (thus modifying the map).
const char * what() const noexcept
Definition: exceptions.hpp:37
Paint the same terrain on a number of locations on the map.
Definition: action.hpp:284
bool dragging_left_
LMB drag init flag.
virtual bool supports_brushes() const
Whether we need the brush bar, is used to grey it out.
bool can_redo() const
static bool quit()
Shows the quit confirmation if needed.
std::vector< std::string > get_area_ids() const
Encapsulates the map of the game.
Definition: location.hpp:42
Helper class, don&#39;t construct this directly.
void perform_partial_action(const editor_action &action)
Performs a partial action, assumes that the top undo action has been modified to maintain coherent st...
unit_iterator find(std::size_t id)
Definition: map.cpp:311
void recalculate_labels()
Definition: label.cpp:244
void set_starting_position_labels(display &disp)
static void display(const config &game_cfg, const preferences::PREFERENCE_VIEW initial_view=preferences::VIEW_DEFAULT)
The display function – see modal_dialog for more information.
static void quit_to_desktop()
void init_gui()
init the display object and general set-up
void scroll_right(bool on) override
void show_help(const std::string &show_topic)
Open the help browser, show topic with id show_topic.
Definition: help.cpp:36
std::size_t i
Definition: function.cpp:933
bool everything_selected() const
Definition: editor_map.cpp:209
void left_mouse_up(int x, int y, const bool browse) override
Called when the left mouse button is up.
virtual void highlight_hex(map_location hex)
Definition: display.cpp:913
Game configuration data as global variables.
Definition: build_info.cpp:46
const config & game_config_
const tod_manager * get_time_manager() const
const std::vector< time_of_day > & times(const map_location &loc=map_location::null_location()) const
Struct which will hide all current floating labels, and cause floating labels instantiated after it i...
const std::string & selected_item() const
Return the currently selected item.
Base class for all editor actions.
Definition: action_base.hpp:40
Internal representation of music tracks.
virtual std::vector< std::string > additional_actions_pressed() override
void set_scroll_right(bool on)
bool empty() const
Definition: map.hpp:432
CURSOR_TYPE get()
Definition: cursor.cpp:213
void cut_selection()
Cut the selection from the current map to the clipboard.
virtual bool do_execute_command(const hotkey_command &command, int index=-1, bool press=true, bool release=false)
DIRECTION
Valid directions which can be moved in our hexagonal world.
Definition: location.hpp:44
void display_redraw_callback(display &)
Callback function passed to display to be called on each redraw_everything run.
editor_controller(const editor_controller &)=delete
std::vector< sound::music_track > music_tracks_
#define N_(String)
Definition: gettext.hpp:97
std::size_t index(const std::string &str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
Definition: unicode.cpp:71
void toggle_grid() override
Grid toggle.
void perform_delete(editor_action *action)
Perform an action, then delete the action object.
bool allow_mouse_wheel_scroll(int x, int y) override
Derived classes can override this to disable mousewheel scrolling under some circumstances, e.g.
void scroll_left(bool on) override
bool can_undo() const
bool grid()
Definition: general.cpp:507
bool left_click(int x, int y, const bool browse) override
Overridden in derived classes, called on a left click (mousedown).
const std::string & file_path() const
virtual const unit_map & units() const override
Const units accessor.
bool do_quit_
Quit main loop flag.
void set_scroll_left(bool on)
EXIT_STATUS main_loop()
Editor main loop.
void copy_to_clipboard(const std::string &text, const bool)
Copies text to the clipboard.
Definition: clipboard.cpp:35
bool minimap_draw_terrain()
Definition: general.cpp:807
virtual const editor_map & map() const override
Const map accessor.
virtual editor_action * drag_end_left(editor_display &disp, int x, int y)
The end of dragging.
void set_draw_terrain_codes(bool value)
Definition: editor.cpp:40
int get_active_area() const
virtual void move(editor_display &disp, const map_location &hex)
Mouse move (not a drag).
#define ERR_ED
bool is_in_playlist(std::string track_id)
Remove a unit from the map.
Definition: action_unit.hpp:63
void replace_local_schedule(const std::vector< time_of_day > &schedule)
Replace the [time]s of the currently active area.
Container associating units to locations.
Definition: map.hpp:99
const std::set< map_location > & get_area_by_index(int index) const
void set_draw_num_of_bitmaps(bool value)
Definition: editor.cpp:56
void init_music(const config &game_config)
init background music for the editor
void show_error_message(const std::string &msg, bool message_use_markup)
Shows an error message to the user.
Definition: message.cpp:203
#define e
int get_current_area_time(int index) const
void set_draw_hex_coordinates(bool value)
Definition: editor.cpp:48
const std::string & title() const
const std::unique_ptr< context_manager > context_manager_
A config object defines a single node in a WML file, with access to child nodes.
Definition: config.hpp:68
mock_char c
void scroll_down(bool on) override
const hotkey_command & get_hotkey_command(const std::string &command)
returns the hotkey_command with the given name
Editor action classes.
void scroll_up(bool on) override
Handle hotkeys to scroll map.
bool right_click(int x, int y, const bool browse) override
Overridden in derived classes, called on a right click (mousedown).
virtual const std::vector< team > & teams() const override
Const teams accessor.
static std::vector< std::string > saved_windows_
std::string::const_iterator iterator
Definition: tokenizer.hpp:24
void redo() override
Redos an action in the current map context.
virtual editor_action * drag_end_right(editor_display &disp, int x, int y)
bool select_area(int index)
Select the nth tod area.
hotkey::ACTION_STATE get_action_state(hotkey::HOTKEY_COMMAND command, int index) const override
command_executor override
bool minimap_terrain_coding()
Definition: general.cpp:777