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 https://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 "game_board.hpp"
46 #include "preferences/game.hpp"
47 #include "gettext.hpp"
48 #include "picture.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()
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, *reports_, 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  , help_manager_(nullptr)
77  , do_quit_(false)
78  , quit_mode_(EXIT_ERROR)
79  , music_tracks_()
80 {
81  init_gui();
82  toolkit_.reset(new editor_toolkit(*gui_.get(), key_, game_config_, *context_manager_.get()));
83  help_manager_.reset(new help::help_manager(&game_config_));
84  context_manager_->locs_ = toolkit_->get_palette_manager()->location_palette_.get();
85  context_manager_->switch_context(0, true);
86  init_tods(game_config_);
87  init_music(game_config_);
90 
91  gui().create_buttons();
93 }
94 
96 {
97  gui_->change_display_context(&get_current_map_context());
99  gui_->add_redraw_observer(std::bind(&editor_controller::display_redraw_callback, this, _1));
104 // halo_manager_.reset(new halo::manager(*gui_));
105 // resources::halo = halo_manager_.get();
106 // ^ These lines no longer necessary, the gui owns its halo manager.
107 // TODO: Should the editor map contexts actually own the halo manager and swap them in and out from the gui?
108 // 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
109 // without deleting it.
110 }
111 
113 {
114  for (const config &schedule : game_config.child_range("editor_times")) {
115 
116  const std::string& schedule_id = schedule["id"];
117  const std::string& schedule_name = schedule["name"];
118  if (schedule_id.empty()) {
119  ERR_ED << "Missing ID attribute in a TOD Schedule." << std::endl;
120  continue;
121  }
122 
123  tods_map::iterator times = tods_.find(schedule_id);
124  if (times == tods_.end()) {
125  std::pair<tods_map::iterator, bool> new_times =
126  tods_.emplace(schedule_id, std::make_pair(schedule_name, std::vector<time_of_day>()));
127 
128  times = new_times.first;
129  } else {
130  ERR_ED << "Duplicate TOD Schedule identifiers." << std::endl;
131  continue;
132  }
133 
134  for (const config &time : schedule.child_range("time")) {
135  times->second.second.emplace_back(time);
136  }
137 
138  }
139 
140  if (tods_.empty()) {
141  ERR_ED << "No editor time-of-day defined" << std::endl;
142  }
143 }
144 
146 {
147  const std::string tag_name = "editor_music";
148  if (!game_config.has_child(tag_name))
149  ERR_ED << "No editor music defined" << std::endl;
150  else {
151  for (const config& editor_music : game_config.child_range(tag_name)) {
152  for (const config& music : editor_music.child_range("music")) {
153  sound::music_track track(music);
154  if (track.file_path().empty())
155  WRN_ED << "Music track " << track.id() << " not found." << std::endl;
156  else
157  music_tracks_.emplace_back(music);
158  }
159  }
160  }
161 }
162 
164 {
165  resources::tod_manager = nullptr;
166  resources::filter_con = nullptr;
167 
168  resources::classification = nullptr;
169 }
170 
172 {
173  try {
174  while (!do_quit_) {
175  play_slice();
176  }
177  } catch (const editor_exception& e) {
178  gui2::show_transient_message(_("Fatal error"), e.what());
179  return EXIT_ERROR;
180  } catch (const wml_exception& e) {
181  e.show();
182  }
183  return quit_mode_;
184 }
185 
187 }
188 
189 void editor_controller::do_screenshot(const std::string& screenshot_filename /* = "map_screenshot.bmp" */)
190 {
191  try {
192  surface screenshot = gui().screenshot(true);
193  if(screenshot.null() || image::save_image(screenshot, screenshot_filename) != image::save_result::success) {
194  ERR_ED << "Screenshot creation failed!\n";
195  }
196  } catch (const wml_exception& e) {
197  e.show();
198  }
199 }
200 
202 {
203  std::string modified;
204  std::size_t amount = context_manager_->modified_maps(modified);
205 
206  std::string message;
207  if (amount == 0) {
208  message = _("Do you really want to quit?");
209  } else if (amount == 1 && get_current_map_context().modified()) {
210  message = _("Do you really want to quit? Changes to this map since the last save will be lost.");
211  } else {
212  message = _("Do you really want to quit? The following maps were modified and all changes since the last save will be lost:");
213  message += "\n" + modified;
214  }
215  return quit_confirmation::show_prompt(message);
216 }
217 
219 {
220  if (tods_.empty()) {
221  gui2::show_error_message(_("No editor time-of-day found."));
222  return;
223  }
224 
226 
227  if(gui2::dialogs::custom_tod::execute(manager.times(), manager.get_current_time())) {
228  // TODO save the new tod here
229  }
230 
231  gui_->update_tod();
232 
233  context_manager_->refresh_all();
234 }
235 
237 {
238  using namespace hotkey; //reduce hotkey:: clutter
239  switch (cmd.id) {
240  case HOTKEY_NULL:
241  if (index >= 0) {
242  unsigned i = static_cast<unsigned>(index);
243 
244  switch (active_menu_) {
245  case editor::MAP:
246  if (i < context_manager_->open_maps()) {
247  return true;
248  }
249  return false;
250  case editor::LOAD_MRU:
251  case editor::PALETTE:
252  case editor::AREA:
253  case editor::SIDE:
254  case editor::TIME:
255  case editor::SCHEDULE:
257  case editor::MUSIC:
258  case editor::LOCAL_TIME:
259  case editor::UNIT_FACING:
260  return true;
261  }
262  }
263  return false;
265  return true;
267  return toolkit_->get_palette_manager()->can_scroll_up();
269  return toolkit_->get_palette_manager()->can_scroll_down();
270  case HOTKEY_ZOOM_IN:
271  return !gui_->zoom_at_max();
272  case HOTKEY_ZOOM_OUT:
273  return !gui_->zoom_at_min();
274  case HOTKEY_ZOOM_DEFAULT:
275  case HOTKEY_FULLSCREEN:
276  case HOTKEY_SCREENSHOT:
278  case HOTKEY_TOGGLE_GRID:
279  case HOTKEY_MOUSE_SCROLL:
280  case HOTKEY_ANIMATE_MAP:
281  case HOTKEY_MUTE:
282  case HOTKEY_PREFERENCES:
283  case HOTKEY_HELP:
284  case HOTKEY_QUIT_GAME:
285  case HOTKEY_SCROLL_UP:
286  case HOTKEY_SCROLL_DOWN:
287  case HOTKEY_SCROLL_LEFT:
288  case HOTKEY_SCROLL_RIGHT:
289  return true; //general hotkeys we can always do
290 
292  return !get_current_map_context().units().empty();
293 
294  case HOTKEY_STATUS_TABLE:
295  return !get_current_map_context().teams().empty();
296 
298  return gui().mouseover_hex().valid();
299 
300  // unit tool related
301  case HOTKEY_DELETE_UNIT:
302  case HOTKEY_RENAME_UNIT:
310  {
311  map_location loc = gui_->mouseover_hex();
312  const unit_map& units = get_current_map_context().units();
313  return (toolkit_->is_mouse_action_set(HOTKEY_EDITOR_TOOL_UNIT) &&
314  units.find(loc) != units.end());
315  }
316  case HOTKEY_UNDO:
318  case HOTKEY_REDO:
330  return true;
331 
335 
338  return !get_current_map_context().teams().empty();
339 
340  // brushes
348 
350  return true;
352  return toolkit_->get_palette_manager()->active_palette().supports_swap();
356  {
357  std::string dummy;
358  return context_manager_->modified_maps(dummy) > 1;
359  }
365  return true;
367  return !get_current_map_context().get_filename().empty()
369 
370  // Tools
371  // Pure map editing tools this can be used all the time.
376  return true;
377  // WWL dependent tools which don't rely on defined sides.
384  return !get_current_map_context().teams().empty();
385 
389  return !get_current_map_context().is_pure_map() &&
391 
393  return !get_current_map_context().is_pure_map() &&
395  && !get_current_map_context().map().selection().empty();
396 
401  return !get_current_map_context().map().selection().empty()
402  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
404  return (get_current_map_context().map().selection().size() > 1
405  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE));
409  return false; //not implemented
411  return !context_manager_->clipboard_empty();
416  return !context_manager_->clipboard_empty()
417  && toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
420  return !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
422  return !get_current_map_context().map().selection().empty()
424  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
441  return true;
443  return false; //not implemented
447  return true;
448  default:
449  return false;
450  }
451 }
452 
454  using namespace hotkey;
455  switch (command) {
456 
458  {
460  get_current_map_context().units().find(gui_->mouseover_hex());
461  return un->loyal() ? ACTION_ON : ACTION_OFF;
462 
463  }
465  {
467  get_current_map_context().units().find(gui_->mouseover_hex());
468  return un->can_recruit() ? ACTION_ON : ACTION_OFF;
469  }
471  {
473  get_current_map_context().units().find(gui_->mouseover_hex());
474  return (!un->unrenamable()) ? ACTION_ON : ACTION_OFF;
475  }
476  //TODO remove hardcoded hotkey names
478  return context_manager_->is_active_transitions_hotkey("editor-auto-update-transitions")
481  return context_manager_->is_active_transitions_hotkey("editor-partial-update-transitions")
484  return context_manager_->is_active_transitions_hotkey("editor-no-update-transitions")
487  return toolkit_->is_active_brush("brush-1") ? ACTION_ON : ACTION_OFF;
489  return toolkit_->is_active_brush("brush-2") ? ACTION_ON : ACTION_OFF;
491  return toolkit_->is_active_brush("brush-3") ? ACTION_ON : ACTION_OFF;
493  return toolkit_->is_active_brush("brush-nw-se") ? ACTION_ON : ACTION_OFF;
495  return toolkit_->is_active_brush("brush-sw-ne") ? ACTION_ON : ACTION_OFF;
496 
497  case HOTKEY_TOGGLE_GRID:
503  return get_current_map_context().map().selection().empty() ?
514  return toolkit_->is_mouse_action_set(command) ? ACTION_ON : ACTION_OFF;
516  return gui_->get_draw_coordinates() ? ACTION_ON : ACTION_OFF;
518  return gui_->get_draw_terrain_codes() ? ACTION_ON : ACTION_OFF;
520  return gui_->get_draw_num_of_bitmaps() ? ACTION_ON : ACTION_OFF;
521 
532  case HOTKEY_ZOOM_DEFAULT:
533  return (gui_->get_zoom_factor() == 1.0) ? hotkey::ACTION_ON : hotkey::ACTION_OFF;
534 
535  case HOTKEY_NULL:
536  switch (active_menu_) {
537  case editor::MAP:
538  return index == context_manager_->current_context_index()
540  case editor::LOAD_MRU:
541  return ACTION_STATELESS;
542  case editor::PALETTE:
543  return ACTION_STATELESS;
544  case editor::AREA:
545  return index == get_current_map_context().get_active_area()
547  case editor::SIDE:
548  return static_cast<std::size_t>(index) == gui_->playing_team()
550  case editor::TIME:
553  case editor::LOCAL_TIME:
555  get_current_map_context().get_active_area())
557  case editor::MUSIC:
559  ? ACTION_ON : ACTION_OFF;
560  case editor::SCHEDULE:
561  {
562  tods_map::const_iterator it = tods_.begin();
563  std::advance(it, index);
564  const std::vector<time_of_day>& times1 = it->second.second;
565  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times();
566  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
567  }
569  {
570  tods_map::const_iterator it = tods_.begin();
571  std::advance(it, index);
572  const std::vector<time_of_day>& times1 = it->second.second;
573  int active_area = get_current_map_context().get_active_area();
574  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times(active_area);
575  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
576  }
577  case editor::UNIT_FACING:
578  {
580  assert(un != get_current_map_context().units().end());
581  return un->facing() == index ? ACTION_SELECTED : ACTION_DESELECTED;
582  }
583  }
584  return ACTION_ON;
585  default:
586  return command_executor::get_action_state(command, index);
587  }
588 }
589 
590 bool editor_controller::do_execute_command(const hotkey::hotkey_command& cmd, int index, bool press, bool release)
591 {
592  hotkey::HOTKEY_COMMAND command = cmd.id;
593  SCOPE_ED;
594  using namespace hotkey;
595 
596  // nothing here handles release; fall through to base implementation
597  if (!press) {
598  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
599  }
600 
601  switch (command) {
602  case HOTKEY_NULL:
603  switch (active_menu_) {
604  case MAP:
605  if (index >= 0) {
606  unsigned i = static_cast<unsigned>(index);
607  if (i < context_manager_->size()) {
608  context_manager_->switch_context(index);
609  toolkit_->hotkey_set_mouse_action(HOTKEY_EDITOR_TOOL_PAINT);
610  return true;
611  }
612  }
613  return false;
614  case LOAD_MRU:
615  if (index >= 0) {
616  context_manager_->load_mru_item(static_cast<unsigned>(index));
617  }
618  return true;
619  case PALETTE:
620  toolkit_->get_palette_manager()->set_group(index);
621  return true;
622  case SIDE:
623  gui_->set_team(index, true);
624  gui_->set_playing_team(index);
625  toolkit_->get_palette_manager()->draw_contents();
626  return true;
627  case AREA:
628  {
630  const std::set<map_location>& area =
632  std::vector<map_location> locs(area.begin(), area.end());
634  gui_->scroll_to_tiles(locs.begin(), locs.end());
635  return true;
636  }
637  case TIME:
638  {
640  gui_->update_tod();
641  return true;
642  }
643  case LOCAL_TIME:
644  {
646  return true;
647  }
648  case MUSIC:
649  {
650  //TODO mark the map as changed
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  return true;
658  }
659  case SCHEDULE:
660  {
661  tods_map::iterator iter = tods_.begin();
662  std::advance(iter, index);
663  get_current_map_context().replace_schedule(iter->second.second);
664  // TODO: test again after the assign-schedule menu is fixed. Should work, though.
665  gui_->update_tod();
666  return true;
667  }
668  case LOCAL_SCHEDULE:
669  {
670  tods_map::iterator iter = tods_.begin();
671  std::advance(iter, index);
672  get_current_map_context().replace_local_schedule(iter->second.second);
673  return true;
674  }
675  case UNIT_FACING:
676  {
678  assert(un != get_current_map_context().units().end());
679  un->set_facing(map_location::DIRECTION(index));
680  un->anim_comp().set_standing();
681  return true;
682  }
683  }
684  return true;
685 
686  //Zoom
687  case HOTKEY_ZOOM_IN:
688  gui_->set_zoom(true);
690  toolkit_->set_mouseover_overlay(*gui_);
691  return true;
692  case HOTKEY_ZOOM_OUT:
693  gui_->set_zoom(false);
695  toolkit_->set_mouseover_overlay(*gui_);
696  return true;
697  case HOTKEY_ZOOM_DEFAULT:
698  gui_->set_default_zoom();
700  toolkit_->set_mouseover_overlay(*gui_);
701  return true;
702 
703  //Palette
705  {
706  //TODO this code waits for the gui2 dialog to get ready
707 // std::vector< std::pair< std::string, std::string >> blah_items;
708 // toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(blah_items);
709 // int selected = 1; //toolkit_->get_palette_manager()->active_palette().get_selected;
710 // gui2::teditor_select_palette_group::execute(selected, blah_items, gui_->video());
711  }
712  return true;
714  toolkit_->get_palette_manager()->scroll_up();
715  return true;
717  toolkit_->get_palette_manager()->scroll_down();
718  return true;
719 
720  case HOTKEY_QUIT_GAME:
722  do_quit_ = true;
724  }
725  return true;
728  return true;
730  context_manager_->save_all_maps(true);
731  do_quit_ = true;
733  return true;
736  return true;
738  toolkit_->get_palette_manager()->active_palette().swap();
739  return true;
741  if (dynamic_cast<const editor_action_chain*>(get_current_map_context().last_undo_action()) != nullptr) {
743  context_manager_->refresh_after_action();
744  } else {
745  undo();
746  }
747  return true;
748 
749  //Tool Selection
758  toolkit_->hotkey_set_mouse_action(command);
759  return true;
760 
762  add_area();
763  return true;
764 
766  change_unit_id();
767  return true;
768 
770  {
771  map_location loc = gui_->mouseover_hex();
773  const std::set<std::string>& recruit_set = toolkit_->get_palette_manager()->unit_palette_->get_selected_bg_items();
774  std::vector<std::string> recruits(recruit_set.begin(), recruit_set.end());
775  un->set_recruits(recruits);
776  }
777  return true;
779  {
780  map_location loc = gui_->mouseover_hex();
782  bool unrenamable = un->unrenamable();
783  un->set_unrenamable(!unrenamable);
784  }
785  return true;
787  {
788  map_location loc = gui_->mouseover_hex();
790  bool canrecruit = un->can_recruit();
791  un->set_can_recruit(!canrecruit);
792  un->anim_comp().set_standing();
793  }
794  return true;
795  case HOTKEY_DELETE_UNIT:
796  {
797  map_location loc = gui_->mouseover_hex();
799  }
800  return true;
801  case HOTKEY_EDITOR_CLIPBOARD_PASTE: //paste is somewhat different as it might be "one action then revert to previous mode"
802  toolkit_->hotkey_set_mouse_action(command);
803  return true;
804 
805  //Clipboard
807  context_manager_->get_clipboard().rotate_60_cw();
808  toolkit_->update_mouse_action_highlights();
809  return true;
811  context_manager_->get_clipboard().rotate_60_ccw();
812  toolkit_->update_mouse_action_highlights();
813  return true;
815  context_manager_->get_clipboard().flip_horizontal();
816  toolkit_->update_mouse_action_highlights();
817  return true;
819  context_manager_->get_clipboard().flip_vertical();
820  toolkit_->update_mouse_action_highlights();
821  return true;
822 
823  //Brushes
825  toolkit_->cycle_brush();
826  return true;
828  toolkit_->set_brush("brush-1");
829  return true;
831  toolkit_->set_brush("brush-2");
832  return true;
834  toolkit_->set_brush("brush-3");
835  return true;
837  toolkit_->set_brush("brush-nw-se");
838  return true;
840  toolkit_->set_brush("brush-sw-ne");
841  return true;
842 
844  copy_selection();
845  return true;
847  cut_selection();
848  return true;
850  context_manager_->rename_area_dialog();
851  return true;
853  save_area();
854  return true;
857  return true;
859  if(!get_current_map_context().map().everything_selected()) {
860  context_manager_->perform_refresh(editor_action_select_all());
861  return true;
862  }
863  FALLTHROUGH;
866  return true;
868  context_manager_->perform_refresh(editor_action_select_none());
869  return true;
871  context_manager_->fill_selection();
872  return true;
875  get_current_map_context().map().selection()));
876  return true;
877 
879  context_manager_->edit_scenario_dialog();
880  return true;
881 
884  get_current_map_context().get_active_area());
885  return true;
886 
887  // map specific
889  context_manager_->close_current_context();
890  return true;
892  context_manager_->load_map_dialog();
893  return true;
895  context_manager_->revert_map();
896  return true;
898  context_manager_->new_map_dialog();
899  return true;
901  context_manager_->new_scenario_dialog();
902  return true;
904  save_map();
905  return true;
907  context_manager_->save_all_maps();
908  return true;
910  context_manager_->save_map_as_dialog();
911  return true;
913  context_manager_->save_scenario_as_dialog();
914  return true;
916  context_manager_->generate_map_dialog();
917  return true;
919  context_manager_->apply_mask_dialog();
920  return true;
922  context_manager_->create_mask_to_dialog();
923  return true;
925  context_manager_->resize_map_dialog();
926  return true;
927 
928  // Side specific ones
930  if(get_current_map_context().teams().size() >= 9) {
931  size_t new_side_num = get_current_map_context().teams().size() + 1;
932  toolkit_->get_palette_manager()->location_palette_->add_item(std::to_string(new_side_num));
933  }
935  gui_->init_flags();
936  return true;
938  gui_->set_team(0, true);
939  gui_->set_playing_team(0);
941  return true;
943  context_manager_->edit_side_dialog(gui_->viewing_team());
944  return true;
945 
946  // Transitions
948  context_manager_->set_update_transitions_mode(2);
949  return true;
951  context_manager_->set_update_transitions_mode(1);
952  return true;
954  context_manager_->set_update_transitions_mode(0);
955  return true;
957  if(context_manager_->toggle_update_transitions()) {
958  return true;
959  }
960  FALLTHROUGH;
962  context_manager_->refresh_all();
963  return true;
964  // Refresh
966  context_manager_->reload_map();
967  return true;
970  return true;
971 
973  gui().set_draw_coordinates(!gui().get_draw_coordinates());
974  preferences::editor::set_draw_hex_coordinates(gui().get_draw_coordinates());
975  gui().invalidate_all();
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  gui().invalidate_all();
981  return true;
983  gui().set_draw_num_of_bitmaps(!gui().get_draw_num_of_bitmaps());
984  preferences::editor::set_draw_num_of_bitmaps(gui().get_draw_num_of_bitmaps());
985  gui().invalidate_all();
986  return true;
988  location_palette* lp = dynamic_cast<location_palette*>(&toolkit_->get_palette_manager()->active_palette());
989  if (lp) {
991  // No idea if this is the right thing to call, but it ensures starting
992  // position labels get removed on delete.
993  context_manager_->refresh_after_action();
994  }
995  return true;
996  }
997  default:
998  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
999  }
1000 }
1001 
1003 {
1004  help::show_help("..editor");
1005 }
1006 
1007 void editor_controller::show_menu(const std::vector<config>& items_arg, int xloc, int yloc, bool context_menu, display& disp)
1008 {
1009  if(context_menu) {
1010  if(!get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(xloc, yloc))) {
1011  return;
1012  }
1013  }
1014 
1015  std::vector<config> items;
1016  for(const auto& c : items_arg) {
1017  const std::string& id = c["id"];
1019 
1020  if((can_execute_command(command) && (!context_menu || in_context_menu(command.id)))
1021  || command.id == hotkey::HOTKEY_NULL)
1022  {
1023  items.emplace_back("id", id);
1024  }
1025  }
1026 
1027  // No point in showing an empty menu.
1028  if(items.empty()) {
1029  return;
1030  }
1031 
1032  // Based on the ID of the first entry, we fill the menu contextually.
1033  const std::string& first_id = items.front()["id"];
1034 
1035  if(first_id == "EDITOR-LOAD-MRU-PLACEHOLDER") {
1037  context_manager_->expand_load_mru_menu(items, 0);
1038  }
1039 
1040  if(first_id == "editor-switch-map") {
1042  context_manager_->expand_open_maps_menu(items, 0);
1043  }
1044 
1045  if(first_id == "editor-palette-groups") {
1047  toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(items, 0);
1048  }
1049 
1050  if(first_id == "editor-switch-side") {
1052  context_manager_->expand_sides_menu(items, 0);
1053  }
1054 
1055  if(first_id == "editor-switch-area") {
1057  context_manager_->expand_areas_menu(items, 0);
1058  }
1059 
1060  if(!items.empty() && items.front()["id"] == "editor-switch-time") {
1062  context_manager_->expand_time_menu(items, 0);
1063  }
1064 
1065  if(first_id == "editor-assign-local-time") {
1067  context_manager_->expand_local_time_menu(items, 0);
1068  }
1069 
1070  if(first_id == "menu-unit-facings") {
1072  auto pos = items.erase(items.begin());
1073  int dir = 0;
1074  std::generate_n(std::inserter<std::vector<config>>(items, pos), static_cast<int>(map_location::NDIRECTIONS), [&dir]() -> config {
1076  });
1077  }
1078 
1079  if(first_id == "editor-playlist") {
1081  auto pos = items.erase(items.begin());
1082  std::transform(music_tracks_.begin(), music_tracks_.end(), std::inserter<std::vector<config>>(items, pos), [](const sound::music_track& track) -> config {
1083  return config {"label", track.title().empty() ? track.id() : track.title()};
1084  });
1085  }
1086 
1087  if(first_id == "editor-assign-schedule") {
1089  auto pos = items.erase(items.begin());
1090  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1091  return config {"label", tod.second.first};
1092  });
1093  }
1094 
1095  if(first_id == "editor-assign-local-schedule") {
1097  auto pos = items.erase(items.begin());
1098  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1099  return config {"label", tod.second.first};
1100  });
1101  }
1102 
1103  command_executor::show_menu(items, xloc, yloc, context_menu, disp);
1104 }
1105 
1107 {
1108  gui_->video().clear_all_help_strings();
1110 
1111  gui_->redraw_everything();
1112 }
1113 
1115 {
1117  gui_->invalidate_all();
1118 }
1119 
1121 {
1122  map_location loc = gui_->mouseover_hex();
1123  const unit_map & units = get_current_map_context().units();
1124  const unit_map::const_unit_iterator un = units.find(loc);
1125  if(un != units.end()) {
1126  help::show_unit_help(un->type_id(), un->type().show_variations_in_help(), false);
1127  } else {
1128  help::show_help("..units");
1129  }
1130 }
1131 
1132 
1134 {
1135  if (!get_current_map_context().map().selection().empty()) {
1136  context_manager_->get_clipboard() = map_fragment(get_current_map_context().map(), get_current_map_context().map().selection());
1137  context_manager_->get_clipboard().center_by_mass();
1138  }
1139 }
1140 
1142 {
1143  map_location loc = gui_->mouseover_hex();
1144  unit_map& units = get_current_map_context().units();
1145  const unit_map::unit_iterator& un = units.find(loc);
1146 
1147  const std::string title(N_("Change Unit ID"));
1148  const std::string label(N_("ID:"));
1149 
1150  if(un != units.end()) {
1151  std::string id = un->id();
1152  if (gui2::dialogs::edit_text::execute(title, label, id)) {
1153  un->set_id(id);
1154  }
1155  }
1156 }
1157 
1159 {
1160  map_location loc = gui_->mouseover_hex();
1161  unit_map& units = get_current_map_context().units();
1162  const unit_map::unit_iterator& un = units.find(loc);
1163 
1164  const std::string title(N_("Rename Unit"));
1165  const std::string label(N_("Name:"));
1166 
1167  if(un != units.end()) {
1168  std::string name = un->name();
1169  if(gui2::dialogs::edit_text::execute(title, label, name)) {
1170  //TODO we may not want a translated name here.
1171  un->set_name(name);
1172  }
1173  }
1174 }
1175 
1177 {
1179 }
1180 
1182 {
1183  copy_selection();
1185 }
1186 
1188 {
1189  const std::set<map_location>& area = get_current_map_context().map().selection();
1191 }
1192 
1194 {
1195  const std::set<map_location>& area = get_current_map_context().map().selection();
1197 }
1198 
1200 {
1201  std::stringstream ssx, ssy;
1202  std::set<map_location>::const_iterator i = get_current_map_context().map().selection().begin();
1203  if (i != get_current_map_context().map().selection().end()) {
1204  ssx << "x = " << i->wml_x();
1205  ssy << "y = " << i->wml_y();
1206  ++i;
1207  while (i != get_current_map_context().map().selection().end()) {
1208  ssx << ", " << i->wml_x();
1209  ssy << ", " << i->wml_y();
1210  ++i;
1211  }
1212  ssx << "\n" << ssy.str() << "\n";
1213  desktop::clipboard::copy_to_clipboard(ssx.str(), false);
1214  }
1215 }
1216 
1218 {
1219  if (action) {
1220  const editor_action_ptr action_auto(action);
1222  }
1223 }
1224 
1225 void editor_controller::perform_refresh_delete(editor_action* action, bool drag_part /* =false */)
1226 {
1227  if (action) {
1228  const editor_action_ptr action_auto(action);
1229  context_manager_->perform_refresh(*action, drag_part);
1230  }
1231 }
1232 
1234 {
1236  context_manager_->refresh_all();
1237 }
1238 
1240 {
1241  set_button_state();
1242  toolkit_->adjust_size();
1243  toolkit_->get_palette_manager()->draw_contents();
1245 }
1246 
1248 {
1250  context_manager_->refresh_after_action();
1251 }
1252 
1254 {
1256  context_manager_->refresh_after_action();
1257 }
1258 
1259 void editor_controller::mouse_motion(int x, int y, const bool /*browse*/,
1260  bool update, map_location /*new_loc*/)
1261 {
1262  if (mouse_handler_base::mouse_motion_default(x, y, update)) return;
1263  map_location hex_clicked = gui().hex_clicked_on(x, y);
1264  if (get_current_map_context().map().on_board_with_border(drag_from_hex_) && is_dragging()) {
1265  editor_action* a = nullptr;
1266  bool partial = false;
1268  if (dragging_left_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(1)) != 0) {
1269  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1270  a = get_mouse_action().drag_left(*gui_, x, y, partial, last_undo);
1271  } else if (dragging_right_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(3)) != 0) {
1272  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1273  a = get_mouse_action().drag_right(*gui_, x, y, partial, last_undo);
1274  }
1275  //Partial means that the mouse action has modified the
1276  //last undo action and the controller shouldn't add
1277  //anything to the undo stack (hence a different perform_ call)
1278  if (a != nullptr) {
1279  const editor_action_ptr aa(a);
1280  if (partial) {
1282  } else {
1284  }
1285  context_manager_->refresh_after_action(true);
1286  }
1287  } else {
1288  get_mouse_action().move(*gui_, hex_clicked);
1289  }
1290  gui().highlight_hex(hex_clicked);
1291 }
1292 
1293 void editor_controller::touch_motion(int /* x */, int /* y */, const bool /* browse */, bool /* update */, map_location /* new_loc */)
1294 {
1295  // Not implemented at all. Sorry, it's a very low priority for iOS port.
1296 }
1297 
1299 {
1300  return get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(x,y));
1301 }
1302 
1303 bool editor_controller::right_click_show_menu(int /*x*/, int /*y*/, const bool /*browse*/)
1304 {
1306 }
1307 
1308 bool editor_controller::left_click(int x, int y, const bool browse)
1309 {
1310  toolkit_->clear_mouseover_overlay();
1311  if (mouse_handler_base::left_click(x, y, browse))
1312  return true;
1313 
1314  LOG_ED << "Left click, after generic handling\n";
1315  map_location hex_clicked = gui().hex_clicked_on(x, y);
1316  if (!get_current_map_context().map().on_board_with_border(hex_clicked))
1317  return true;
1318 
1319  LOG_ED << "Left click action " << hex_clicked << "\n";
1321  perform_refresh_delete(a, true);
1322  if (a) set_button_state();
1323 
1324  return false;
1325 }
1326 
1327 void editor_controller::left_drag_end(int x, int y, const bool /*browse*/)
1328 {
1330  perform_delete(a);
1331 }
1332 
1333 void editor_controller::left_mouse_up(int x, int y, const bool /*browse*/)
1334 {
1336  perform_delete(a);
1337  if (a) set_button_state();
1338  toolkit_->set_mouseover_overlay();
1339  context_manager_->refresh_after_action();
1340 }
1341 
1342 bool editor_controller::right_click(int x, int y, const bool browse)
1343 {
1344  toolkit_->clear_mouseover_overlay();
1345  if (mouse_handler_base::right_click(x, y, browse)) return true;
1346  LOG_ED << "Right click, after generic handling\n";
1347  map_location hex_clicked = gui().hex_clicked_on(x, y);
1348  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return true;
1349  LOG_ED << "Right click action " << hex_clicked << "\n";
1351  perform_refresh_delete(a, true);
1352  if (a) set_button_state();
1353  return false;
1354 }
1355 
1356 void editor_controller::right_drag_end(int x, int y, const bool /*browse*/)
1357 {
1359  perform_delete(a);
1360 }
1361 
1362 void editor_controller::right_mouse_up(int x, int y, const bool browse)
1363 {
1364  // Call base method to handle context menus.
1365  mouse_handler_base::right_mouse_up(x, y, browse);
1366 
1368  perform_delete(a);
1369  if (a) set_button_state();
1370  toolkit_->set_mouseover_overlay();
1371  context_manager_->refresh_after_action();
1372 }
1373 
1375 {
1376  const map_location& loc = gui().mouseover_hex();
1377  if (get_current_map_context().map().on_board(loc) == false)
1378  return;
1379 
1382 }
1383 
1384 void editor_controller::process_keyup_event(const SDL_Event& event)
1385 {
1386  editor_action* a = get_mouse_action().key_event(gui(), event);
1388  toolkit_->set_mouseover_overlay();
1389 }
1390 
1392  return this;
1393 }
1394 
1396 {
1398 }
1399 
1401 {
1403 }
1404 
1406 {
1408 }
1409 
1411 {
1413 }
1414 
1416 {
1417  return toolkit_->get_palette_manager()->active_palette().action_pressed();
1418 }
1419 
1420 } //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:285
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:365
void set_scroll_down(bool on)
unit_iterator end()
Definition: map.hpp:415
bool minimap_draw_units()
Definition: general.cpp:923
void show_help(const std::string &show_topic, int xloc, int yloc)
Open the help browser, show topic with id show_topic.
Definition: help.cpp:116
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:360
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:63
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:570
bool quit_confirm()
Show a quit confirmation dialog and returns true if the user pressed &#39;yes&#39;.
bool draw_num_of_bitmaps()
Definition: editor.cpp:52
Editor action classes.
void save_area(const std::set< map_location > &area)
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
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:903
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:199
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)
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, const bool restore_background)
Shows a transient message to the user.
int get_current_time(const map_location &loc=map_location::null_location()) const
void redraw_everything()
Invalidates entire screen, including all tiles and sidebar.
Definition: display.cpp:2376
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: picture.cpp:1290
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:97
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.
bool null() const
Definition: surface.hpp:79
Unit and team statistics.
void remove_area(int index)
void flush_cache()
Definition: picture.cpp:234
bool modified() const
#define b
#define WRN_ED
bool minimap_draw_villages()
Definition: general.cpp:933
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.
static const char * name(const std::vector< SDL_Joystick *> &joysticks, const std::size_t index)
Definition: joystick.cpp:48
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:761
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:382
void remove_side()
removes the last side from the scenario
Definition: map_context.hpp:95
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
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:355
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.
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:390
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 create_buttons()
Definition: display.cpp:851
void touch_motion(int x, int y, const bool browse, bool update=false, map_location new_loc=map_location::null_location()) override
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
void invalidate_all()
Function to invalidate all tiles.
Definition: display.cpp:2969
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
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:1598
Game configuration data as global variables.
Definition: build_info.cpp:49
void show_unit_help(const std::string &show_topic, bool has_variations, bool hidden, int xloc, int yloc)
Open the help browser, show unit with id unit_id.
Definition: help.cpp:126
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
structure which will hide all current floating labels, and cause floating labels instantiated after 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.
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:505
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:943
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
std::unique_ptr< help::help_manager > help_manager_
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:205
#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
editor_controller()
The constructor.
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:92
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:913