The Battle for Wesnoth  1.15.10+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 #include "game_config_manager.hpp"
54 #include "quit_confirmation.hpp"
55 
56 #include <functional>
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, std::placeholders::_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::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.child_range(tag_name).size() == 0) {
149  ERR_ED << "No editor music defined" << std::endl;
150  }
151  else {
152  for (const config& editor_music : game_config.child_range(tag_name)) {
153  for (const config& music : editor_music.child_range("music")) {
154  sound::music_track track(music);
155  if (track.file_path().empty())
156  WRN_ED << "Music track " << track.id() << " not found." << std::endl;
157  else
158  music_tracks_.emplace_back(music);
159  }
160  }
161  }
162 }
163 
165 {
166  resources::tod_manager = nullptr;
167  resources::filter_con = nullptr;
168 
169  resources::classification = nullptr;
170 }
171 
173 {
174  try {
175  while (!do_quit_) {
176  play_slice();
177  }
178  } catch (const editor_exception& e) {
179  gui2::show_transient_message(_("Fatal error"), e.what());
180  return EXIT_ERROR;
181  } catch (const wml_exception& e) {
182  e.show();
183  }
184  return quit_mode_;
185 }
186 
188 }
189 
190 void editor_controller::do_screenshot(const std::string& screenshot_filename /* = "map_screenshot.bmp" */)
191 {
192  try {
193  surface screenshot = gui().screenshot(true);
194  if(!screenshot || image::save_image(screenshot, screenshot_filename) != image::save_result::success) {
195  ERR_ED << "Screenshot creation failed!\n";
196  }
197  } catch (const wml_exception& e) {
198  e.show();
199  }
200 }
201 
203 {
204  std::string modified;
205  std::size_t amount = context_manager_->modified_maps(modified);
206 
207  std::string message;
208  if (amount == 0) {
209  message = _("Do you really want to quit?");
210  } else if (amount == 1 && get_current_map_context().modified()) {
211  message = _("Do you really want to quit? Changes to this map since the last save will be lost.");
212  } else {
213  message = _("Do you really want to quit? The following maps were modified and all changes since the last save will be lost:");
214  message += "\n" + modified;
215  }
216  return quit_confirmation::show_prompt(message);
217 }
218 
220 {
221  if (tods_.empty()) {
222  gui2::show_error_message(_("No editor time-of-day found."));
223  return;
224  }
225 
227 
228  if(gui2::dialogs::custom_tod::execute(manager.times(), manager.get_current_time())) {
229  // TODO save the new tod here
230  }
231 
232  gui_->update_tod();
233 
234  context_manager_->refresh_all();
235 }
236 
238 {
239  using namespace hotkey; //reduce hotkey:: clutter
240  switch (cmd.id) {
241  case HOTKEY_NULL:
242  if (index >= 0) {
243  unsigned i = static_cast<unsigned>(index);
244 
245  switch (active_menu_) {
246  case editor::MAP:
247  if (i < context_manager_->open_maps()) {
248  return true;
249  }
250  return false;
251  case editor::LOAD_MRU:
252  case editor::PALETTE:
253  case editor::AREA:
254  case editor::SIDE:
255  case editor::TIME:
256  case editor::SCHEDULE:
258  case editor::MUSIC:
259  case editor::LOCAL_TIME:
260  case editor::UNIT_FACING:
261  return true;
262  }
263  }
264  return false;
266  return true;
268  return toolkit_->get_palette_manager()->can_scroll_up();
270  return toolkit_->get_palette_manager()->can_scroll_down();
271  case HOTKEY_ZOOM_IN:
272  return !gui_->zoom_at_max();
273  case HOTKEY_ZOOM_OUT:
274  return !gui_->zoom_at_min();
275  case HOTKEY_ZOOM_DEFAULT:
276  case HOTKEY_FULLSCREEN:
277  case HOTKEY_SCREENSHOT:
279  case HOTKEY_TOGGLE_GRID:
280  case HOTKEY_MOUSE_SCROLL:
281  case HOTKEY_ANIMATE_MAP:
282  case HOTKEY_MUTE:
283  case HOTKEY_PREFERENCES:
284  case HOTKEY_HELP:
285  case HOTKEY_QUIT_GAME:
286  case HOTKEY_SCROLL_UP:
287  case HOTKEY_SCROLL_DOWN:
288  case HOTKEY_SCROLL_LEFT:
289  case HOTKEY_SCROLL_RIGHT:
290  return true; //general hotkeys we can always do
291 
293  return !get_current_map_context().units().empty();
294 
295  case HOTKEY_STATUS_TABLE:
296  return !get_current_map_context().teams().empty();
297 
299  return gui().mouseover_hex().valid();
300 
301  // unit tool related
302  case HOTKEY_DELETE_UNIT:
303  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 !context_manager_->clipboard_empty();
414  return !context_manager_->clipboard_empty()
415  && toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
418  return !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
420  return !get_current_map_context().map().selection().empty()
422  && !toolkit_->is_mouse_action_set(HOTKEY_EDITOR_CLIPBOARD_PASTE);
439  return true;
443  return true;
444  default:
445  return false;
446  }
447 }
448 
450  using namespace hotkey;
451  switch (command) {
452 
454  {
456  get_current_map_context().units().find(gui_->mouseover_hex());
457  return un->loyal() ? ACTION_ON : ACTION_OFF;
458 
459  }
461  {
463  get_current_map_context().units().find(gui_->mouseover_hex());
464  return un->can_recruit() ? ACTION_ON : ACTION_OFF;
465  }
467  {
469  get_current_map_context().units().find(gui_->mouseover_hex());
470  return (!un->unrenamable()) ? ACTION_ON : ACTION_OFF;
471  }
472  //TODO remove hardcoded hotkey names
474  return context_manager_->is_active_transitions_hotkey("editor-auto-update-transitions")
477  return context_manager_->is_active_transitions_hotkey("editor-partial-update-transitions")
480  return context_manager_->is_active_transitions_hotkey("editor-no-update-transitions")
483  return toolkit_->is_active_brush("brush-1") ? ACTION_ON : ACTION_OFF;
485  return toolkit_->is_active_brush("brush-2") ? ACTION_ON : ACTION_OFF;
487  return toolkit_->is_active_brush("brush-3") ? ACTION_ON : ACTION_OFF;
489  return toolkit_->is_active_brush("brush-nw-se") ? ACTION_ON : ACTION_OFF;
491  return toolkit_->is_active_brush("brush-sw-ne") ? ACTION_ON : ACTION_OFF;
492 
493  case HOTKEY_TOGGLE_GRID:
499  return get_current_map_context().map().selection().empty() ?
510  return toolkit_->is_mouse_action_set(command) ? ACTION_ON : ACTION_OFF;
512  return gui_->get_draw_coordinates() ? ACTION_ON : ACTION_OFF;
514  return gui_->get_draw_terrain_codes() ? ACTION_ON : ACTION_OFF;
516  return gui_->get_draw_num_of_bitmaps() ? ACTION_ON : ACTION_OFF;
517 
528  case HOTKEY_ZOOM_DEFAULT:
529  return (gui_->get_zoom_factor() == 1.0) ? hotkey::ACTION_ON : hotkey::ACTION_OFF;
530 
531  case HOTKEY_NULL:
532  switch (active_menu_) {
533  case editor::MAP:
534  return index == context_manager_->current_context_index()
536  case editor::LOAD_MRU:
537  return ACTION_STATELESS;
538  case editor::PALETTE:
539  return ACTION_STATELESS;
540  case editor::AREA:
541  return index == get_current_map_context().get_active_area()
543  case editor::SIDE:
544  return static_cast<std::size_t>(index) == gui_->playing_team()
546  case editor::TIME:
549  case editor::LOCAL_TIME:
551  get_current_map_context().get_active_area())
553  case editor::MUSIC:
555  ? ACTION_ON : ACTION_OFF;
556  case editor::SCHEDULE:
557  {
558  tods_map::const_iterator it = tods_.begin();
559  std::advance(it, index);
560  const std::vector<time_of_day>& times1 = it->second.second;
561  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times();
562  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
563  }
565  {
566  tods_map::const_iterator it = tods_.begin();
567  std::advance(it, index);
568  const std::vector<time_of_day>& times1 = it->second.second;
569  int active_area = get_current_map_context().get_active_area();
570  const std::vector<time_of_day>& times2 = get_current_map_context().get_time_manager()->times(active_area);
571  return (times1 == times2) ? ACTION_SELECTED : ACTION_DESELECTED;
572  }
573  case editor::UNIT_FACING:
574  {
576  assert(un != get_current_map_context().units().end());
577  return un->facing() == index ? ACTION_SELECTED : ACTION_DESELECTED;
578  }
579  }
580  return ACTION_ON;
581  default:
582  return command_executor::get_action_state(command, index);
583  }
584 }
585 
586 bool editor_controller::do_execute_command(const hotkey::hotkey_command& cmd, int index, bool press, bool release)
587 {
588  hotkey::HOTKEY_COMMAND command = cmd.id;
589  SCOPE_ED;
590  using namespace hotkey;
591 
592  // nothing here handles release; fall through to base implementation
593  if (!press) {
594  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
595  }
596 
597  switch (command) {
598  case HOTKEY_NULL:
599  switch (active_menu_) {
600  case MAP:
601  if (index >= 0) {
602  unsigned i = static_cast<unsigned>(index);
603  if (i < context_manager_->size()) {
604  context_manager_->switch_context(index);
605  toolkit_->hotkey_set_mouse_action(HOTKEY_EDITOR_TOOL_PAINT);
606  return true;
607  }
608  }
609  return false;
610  case LOAD_MRU:
611  if (index >= 0) {
612  context_manager_->load_mru_item(static_cast<unsigned>(index));
613  }
614  return true;
615  case PALETTE:
616  toolkit_->get_palette_manager()->set_group(index);
617  return true;
618  case SIDE:
619  gui_->set_team(index, true);
620  gui_->set_playing_team(index);
621  toolkit_->get_palette_manager()->draw_contents();
622  return true;
623  case AREA:
624  {
626  const std::set<map_location>& area =
628  std::vector<map_location> locs(area.begin(), area.end());
630  gui_->scroll_to_tiles(locs.begin(), locs.end());
631  return true;
632  }
633  case TIME:
634  {
636  gui_->update_tod();
637  return true;
638  }
639  case LOCAL_TIME:
640  {
642  return true;
643  }
644  case MUSIC:
645  {
646  //TODO mark the map as changed
649  std::vector<config> items;
650  items.emplace_back("id", "editor-playlist");
651  std::shared_ptr<gui::button> b = gui_->find_menu_button("menu-playlist");
652  show_menu(items, b->location().x +1, b->location().y + b->height() +1, false, *gui_);
653  return true;
654  }
655  case SCHEDULE:
656  {
657  tods_map::iterator iter = tods_.begin();
658  std::advance(iter, index);
659  get_current_map_context().replace_schedule(iter->second.second);
660  // TODO: test again after the assign-schedule menu is fixed. Should work, though.
661  gui_->update_tod();
662  return true;
663  }
664  case LOCAL_SCHEDULE:
665  {
666  tods_map::iterator iter = tods_.begin();
667  std::advance(iter, index);
668  get_current_map_context().replace_local_schedule(iter->second.second);
669  return true;
670  }
671  case UNIT_FACING:
672  {
674  assert(un != get_current_map_context().units().end());
675  un->set_facing(map_location::DIRECTION(index));
676  un->anim_comp().set_standing();
677  return true;
678  }
679  }
680  return true;
681 
682  //Zoom
683  case HOTKEY_ZOOM_IN:
684  gui_->set_zoom(true);
686  toolkit_->set_mouseover_overlay(*gui_);
687  return true;
688  case HOTKEY_ZOOM_OUT:
689  gui_->set_zoom(false);
691  toolkit_->set_mouseover_overlay(*gui_);
692  return true;
693  case HOTKEY_ZOOM_DEFAULT:
694  gui_->toggle_default_zoom();
696  toolkit_->set_mouseover_overlay(*gui_);
697  return true;
698 
699  //Palette
701  {
702  //TODO this code waits for the gui2 dialog to get ready
703 // std::vector< std::pair< std::string, std::string >> blah_items;
704 // toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(blah_items);
705 // int selected = 1; //toolkit_->get_palette_manager()->active_palette().get_selected;
706 // gui2::teditor_select_palette_group::execute(selected, blah_items, gui_->video());
707  }
708  return true;
710  toolkit_->get_palette_manager()->scroll_up();
711  return true;
713  toolkit_->get_palette_manager()->scroll_down();
714  return true;
715 
716  case HOTKEY_QUIT_GAME:
718  do_quit_ = true;
720  }
721  return true;
724  return true;
726  context_manager_->save_all_maps(true);
727  do_quit_ = true;
729  return true;
732  return true;
734  toolkit_->get_palette_manager()->active_palette().swap();
735  return true;
737  if (dynamic_cast<const editor_action_chain*>(get_current_map_context().last_undo_action()) != nullptr) {
739  context_manager_->refresh_after_action();
740  } else {
741  undo();
742  }
743  return true;
744 
745  //Tool Selection
754  toolkit_->hotkey_set_mouse_action(command);
755  return true;
756 
758  add_area();
759  return true;
760 
762  change_unit_id();
763  return true;
764 
765  return true;
767  {
768  map_location loc = gui_->mouseover_hex();
770  bool unrenamable = un->unrenamable();
771  un->set_unrenamable(!unrenamable);
772  }
773  return true;
775  {
776  map_location loc = gui_->mouseover_hex();
778  bool canrecruit = un->can_recruit();
779  un->set_can_recruit(!canrecruit);
780  un->anim_comp().set_standing();
781  }
782  return true;
783  case HOTKEY_DELETE_UNIT:
784  {
785  map_location loc = gui_->mouseover_hex();
786  perform_delete(std::make_unique<editor_action_unit_delete>(loc));
787  }
788  return true;
789  case HOTKEY_EDITOR_CLIPBOARD_PASTE: //paste is somewhat different as it might be "one action then revert to previous mode"
790  toolkit_->hotkey_set_mouse_action(command);
791  return true;
792 
793  //Clipboard
795  context_manager_->get_clipboard().rotate_60_cw();
796  toolkit_->update_mouse_action_highlights();
797  return true;
799  context_manager_->get_clipboard().rotate_60_ccw();
800  toolkit_->update_mouse_action_highlights();
801  return true;
803  context_manager_->get_clipboard().flip_horizontal();
804  toolkit_->update_mouse_action_highlights();
805  return true;
807  context_manager_->get_clipboard().flip_vertical();
808  toolkit_->update_mouse_action_highlights();
809  return true;
810 
811  //Brushes
813  toolkit_->cycle_brush();
814  return true;
816  toolkit_->set_brush("brush-1");
817  return true;
819  toolkit_->set_brush("brush-2");
820  return true;
822  toolkit_->set_brush("brush-3");
823  return true;
825  toolkit_->set_brush("brush-nw-se");
826  return true;
828  toolkit_->set_brush("brush-sw-ne");
829  return true;
830 
832  copy_selection();
833  return true;
835  cut_selection();
836  return true;
838  context_manager_->rename_area_dialog();
839  return true;
841  save_area();
842  return true;
845  return true;
847  if(!get_current_map_context().map().everything_selected()) {
848  context_manager_->perform_refresh(editor_action_select_all());
849  return true;
850  }
851  [[fallthrough]];
854  return true;
856  context_manager_->perform_refresh(editor_action_select_none());
857  return true;
859  context_manager_->fill_selection();
860  return true;
863  get_current_map_context().map().selection()));
864  return true;
865 
867  context_manager_->edit_scenario_dialog();
868  return true;
869 
872  get_current_map_context().get_active_area());
873  return true;
874 
875  // map specific
877  context_manager_->close_current_context();
878  return true;
880  context_manager_->load_map_dialog();
881  return true;
883  context_manager_->revert_map();
884  return true;
886  context_manager_->new_map_dialog();
887  return true;
889  context_manager_->new_scenario_dialog();
890  return true;
892  save_map();
893  return true;
895  context_manager_->save_all_maps();
896  return true;
898  context_manager_->save_map_as_dialog();
899  return true;
901  context_manager_->save_scenario_as_dialog();
902  return true;
904  context_manager_->generate_map_dialog();
905  return true;
907  context_manager_->apply_mask_dialog();
908  return true;
910  context_manager_->create_mask_to_dialog();
911  return true;
913  context_manager_->resize_map_dialog();
914  return true;
915 
916  // Side specific ones
918  if(get_current_map_context().teams().size() >= 9) {
919  size_t new_side_num = get_current_map_context().teams().size() + 1;
920  toolkit_->get_palette_manager()->location_palette_->add_item(std::to_string(new_side_num));
921  }
923  gui_->init_flags();
924  return true;
926  gui_->set_team(0, true);
927  gui_->set_playing_team(0);
929  return true;
931  context_manager_->edit_side_dialog(gui_->viewing_team());
932  return true;
933 
934  // Transitions
936  context_manager_->set_update_transitions_mode(2);
937  return true;
939  context_manager_->set_update_transitions_mode(1);
940  return true;
942  context_manager_->set_update_transitions_mode(0);
943  return true;
945  if(context_manager_->toggle_update_transitions()) {
946  return true;
947  }
948  [[fallthrough]];
950  context_manager_->refresh_all();
951  return true;
952  // Refresh
954  context_manager_->reload_map();
955  return true;
958  return true;
959 
961  gui().set_draw_coordinates(!gui().get_draw_coordinates());
962  preferences::editor::set_draw_hex_coordinates(gui().get_draw_coordinates());
963  gui().invalidate_all();
964  return true;
966  gui().set_draw_terrain_codes(!gui().get_draw_terrain_codes());
967  preferences::editor::set_draw_terrain_codes(gui().get_draw_terrain_codes());
968  gui().invalidate_all();
969  return true;
971  gui().set_draw_num_of_bitmaps(!gui().get_draw_num_of_bitmaps());
972  preferences::editor::set_draw_num_of_bitmaps(gui().get_draw_num_of_bitmaps());
973  gui().invalidate_all();
974  return true;
976  location_palette* lp = dynamic_cast<location_palette*>(&toolkit_->get_palette_manager()->active_palette());
977  if (lp) {
978  perform_delete(std::make_unique<editor_action_starting_position>(map_location(), lp->selected_item()));
979  // No idea if this is the right thing to call, but it ensures starting
980  // position labels get removed on delete.
981  context_manager_->refresh_after_action();
982  }
983  return true;
984  }
985  default:
986  return hotkey::command_executor::do_execute_command(cmd, index, press, release);
987  }
988 }
989 
991 {
992  help::show_help("..editor");
993 }
994 
995 void editor_controller::show_menu(const std::vector<config>& items_arg, int xloc, int yloc, bool context_menu, display& disp)
996 {
997  if(context_menu) {
998  if(!get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(xloc, yloc))) {
999  return;
1000  }
1001  }
1002 
1003  std::vector<config> items;
1004  for(const auto& c : items_arg) {
1005  const std::string& id = c["id"];
1007 
1008  if((can_execute_command(command) && (!context_menu || in_context_menu(command.id)))
1009  || command.id == hotkey::HOTKEY_NULL)
1010  {
1011  items.emplace_back("id", id);
1012  }
1013  }
1014 
1015  // No point in showing an empty menu.
1016  if(items.empty()) {
1017  return;
1018  }
1019 
1020  // Based on the ID of the first entry, we fill the menu contextually.
1021  const std::string& first_id = items.front()["id"];
1022 
1023  if(first_id == "EDITOR-LOAD-MRU-PLACEHOLDER") {
1025  context_manager_->expand_load_mru_menu(items, 0);
1026  }
1027 
1028  if(first_id == "editor-switch-map") {
1030  context_manager_->expand_open_maps_menu(items, 0);
1031  }
1032 
1033  if(first_id == "editor-palette-groups") {
1035  toolkit_->get_palette_manager()->active_palette().expand_palette_groups_menu(items, 0);
1036  }
1037 
1038  if(first_id == "editor-switch-side") {
1040  context_manager_->expand_sides_menu(items, 0);
1041  }
1042 
1043  if(first_id == "editor-switch-area") {
1045  context_manager_->expand_areas_menu(items, 0);
1046  }
1047 
1048  if(!items.empty() && items.front()["id"] == "editor-switch-time") {
1050  context_manager_->expand_time_menu(items, 0);
1051  }
1052 
1053  if(first_id == "editor-assign-local-time") {
1055  context_manager_->expand_local_time_menu(items, 0);
1056  }
1057 
1058  if(first_id == "menu-unit-facings") {
1060  auto pos = items.erase(items.begin());
1061  int dir = 0;
1062  std::generate_n(std::inserter<std::vector<config>>(items, pos), static_cast<int>(map_location::NDIRECTIONS), [&dir]() -> config {
1064  });
1065  }
1066 
1067  if(first_id == "editor-playlist") {
1069  auto pos = items.erase(items.begin());
1070  std::transform(music_tracks_.begin(), music_tracks_.end(), std::inserter<std::vector<config>>(items, pos), [](const sound::music_track& track) -> config {
1071  return config {"label", track.title().empty() ? track.id() : track.title()};
1072  });
1073  }
1074 
1075  if(first_id == "editor-assign-schedule") {
1077  auto pos = items.erase(items.begin());
1078  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1079  return config {"label", tod.second.first};
1080  });
1081  }
1082 
1083  if(first_id == "editor-assign-local-schedule") {
1085  auto pos = items.erase(items.begin());
1086  std::transform(tods_.begin(), tods_.end(), std::inserter<std::vector<config>>(items, pos), [](const tods_map::value_type& tod) -> config {
1087  return config {"label", tod.second.first};
1088  });
1089  }
1090 
1091  command_executor::show_menu(items, xloc, yloc, context_menu, disp);
1092 }
1093 
1095 {
1096  gui_->video().clear_all_help_strings();
1097  gui2::dialogs::preferences_dialog::display();
1098 
1099  gui_->redraw_everything();
1100 }
1101 
1103 {
1105  gui_->invalidate_all();
1106 }
1107 
1109 {
1110  map_location loc = gui_->mouseover_hex();
1111  const unit_map & units = get_current_map_context().units();
1112  const unit_map::const_unit_iterator un = units.find(loc);
1113  if(un != units.end()) {
1114  help::show_unit_help(un->type_id(), un->type().show_variations_in_help(), false);
1115  } else {
1116  help::show_help("..units");
1117  }
1118 }
1119 
1120 
1122 {
1123  if (!get_current_map_context().map().selection().empty()) {
1124  context_manager_->get_clipboard() = map_fragment(get_current_map_context().map(), get_current_map_context().map().selection());
1125  context_manager_->get_clipboard().center_by_mass();
1126  }
1127 }
1128 
1130 {
1131  map_location loc = gui_->mouseover_hex();
1132  unit_map& units = get_current_map_context().units();
1133  const unit_map::unit_iterator& un = units.find(loc);
1134 
1135  const std::string title(N_("Change Unit ID"));
1136  const std::string label(N_("ID:"));
1137 
1138  if(un != units.end()) {
1139  std::string id = un->id();
1140  if (gui2::dialogs::edit_text::execute(title, label, id)) {
1141  un->set_id(id);
1142  }
1143  }
1144 }
1145 
1147 {
1148  map_location loc = gui_->mouseover_hex();
1149  unit_map& units = get_current_map_context().units();
1150  const unit_map::unit_iterator& un = units.find(loc);
1151 
1152  const std::string title(N_("Rename Unit"));
1153  const std::string label(N_("Name:"));
1154 
1155  if(un != units.end()) {
1156  std::string name = un->name();
1157  if(gui2::dialogs::edit_text::execute(title, label, name)) {
1158  //TODO we may not want a translated name here.
1159  un->set_name(name);
1160  }
1161  }
1162 }
1163 
1165 {
1167 }
1168 
1170 {
1171  copy_selection();
1173 }
1174 
1176 {
1177  const std::set<map_location>& area = get_current_map_context().map().selection();
1179 }
1180 
1182 {
1183  const std::set<map_location>& area = get_current_map_context().map().selection();
1185 }
1186 
1188 {
1189  std::stringstream ssx, ssy;
1190  std::set<map_location>::const_iterator i = get_current_map_context().map().selection().begin();
1191  if (i != get_current_map_context().map().selection().end()) {
1192  ssx << "x = " << i->wml_x();
1193  ssy << "y = " << i->wml_y();
1194  ++i;
1195  while (i != get_current_map_context().map().selection().end()) {
1196  ssx << ", " << i->wml_x();
1197  ssy << ", " << i->wml_y();
1198  ++i;
1199  }
1200  ssx << "\n" << ssy.str() << "\n";
1201  desktop::clipboard::copy_to_clipboard(ssx.str(), false);
1202  }
1203 }
1204 
1205 void editor_controller::perform_delete(std::unique_ptr<editor_action> action)
1206 {
1207  if (action) {
1209  }
1210 }
1211 
1212 void editor_controller::perform_refresh_delete(std::unique_ptr<editor_action> action, bool drag_part /* =false */)
1213 {
1214  if (action) {
1215  context_manager_->perform_refresh(*action, drag_part);
1216  }
1217 }
1218 
1220 {
1222  context_manager_->refresh_all();
1223 }
1224 
1226 {
1227  set_button_state();
1228  toolkit_->adjust_size();
1229  toolkit_->get_palette_manager()->draw_contents();
1231 }
1232 
1234 {
1236  context_manager_->refresh_after_action();
1237 }
1238 
1240 {
1242  context_manager_->refresh_after_action();
1243 }
1244 
1245 void editor_controller::mouse_motion(int x, int y, const bool /*browse*/,
1246  bool update, map_location /*new_loc*/)
1247 {
1248  if (mouse_handler_base::mouse_motion_default(x, y, update)) return;
1249  map_location hex_clicked = gui().hex_clicked_on(x, y);
1250  if (get_current_map_context().map().on_board_with_border(drag_from_hex_) && is_dragging()) {
1251  std::unique_ptr<editor_action> a;
1252  bool partial = false;
1253  // last_undo is a non-owning pointer. Although it could have other uses, it seems to be
1254  // mainly (only?) used for printing debugging information.
1255  auto last_undo = get_current_map_context().last_undo_action();
1256  if (dragging_left_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(1)) != 0) {
1257  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1258  a = get_mouse_action().drag_left(*gui_, x, y, partial, last_undo);
1259  } else if (dragging_right_ && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(3)) != 0) {
1260  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return;
1261  a = get_mouse_action().drag_right(*gui_, x, y, partial, last_undo);
1262  }
1263  //Partial means that the mouse action has modified the
1264  //last undo action and the controller shouldn't add
1265  //anything to the undo stack (hence a different perform_ call)
1266  if (a != nullptr) {
1267  if (partial) {
1269  } else {
1271  }
1272  context_manager_->refresh_after_action(true);
1273  }
1274  } else {
1275  get_mouse_action().move(*gui_, hex_clicked);
1276  }
1277  gui().highlight_hex(hex_clicked);
1278 }
1279 
1280 void editor_controller::touch_motion(int /* x */, int /* y */, const bool /* browse */, bool /* update */, map_location /* new_loc */)
1281 {
1282  // Not implemented at all. Sorry, it's a very low priority for iOS port.
1283 }
1284 
1286 {
1287  return get_current_map_context().map().on_board_with_border(gui().hex_clicked_on(x,y));
1288 }
1289 
1290 bool editor_controller::right_click_show_menu(int /*x*/, int /*y*/, const bool /*browse*/)
1291 {
1293 }
1294 
1295 bool editor_controller::left_click(int x, int y, const bool browse)
1296 {
1297  toolkit_->clear_mouseover_overlay();
1298  if (mouse_handler_base::left_click(x, y, browse))
1299  return true;
1300 
1301  LOG_ED << "Left click, after generic handling\n";
1302  map_location hex_clicked = gui().hex_clicked_on(x, y);
1303  if (!get_current_map_context().map().on_board_with_border(hex_clicked))
1304  return true;
1305 
1306  LOG_ED << "Left click action " << hex_clicked << "\n";
1307  auto a = get_mouse_action().click_left(*gui_, x, y);
1308  if(a) {
1309  perform_refresh_delete(std::move(a), true);
1310  set_button_state();
1311  }
1312 
1313  return false;
1314 }
1315 
1316 void editor_controller::left_drag_end(int x, int y, const bool /*browse*/)
1317 {
1318  auto a = get_mouse_action().drag_end_left(*gui_, x, y);
1319  perform_delete(std::move(a));
1320 }
1321 
1322 void editor_controller::left_mouse_up(int x, int y, const bool /*browse*/)
1323 {
1324  auto a = get_mouse_action().up_left(*gui_, x, y);
1325  if(a) {
1326  perform_delete(std::move(a));
1327  set_button_state();
1328  }
1329  toolkit_->set_mouseover_overlay();
1330  context_manager_->refresh_after_action();
1331 }
1332 
1333 bool editor_controller::right_click(int x, int y, const bool browse)
1334 {
1335  toolkit_->clear_mouseover_overlay();
1336  if (mouse_handler_base::right_click(x, y, browse)) return true;
1337  LOG_ED << "Right click, after generic handling\n";
1338  map_location hex_clicked = gui().hex_clicked_on(x, y);
1339  if (!get_current_map_context().map().on_board_with_border(hex_clicked)) return true;
1340  LOG_ED << "Right click action " << hex_clicked << "\n";
1341  auto a = get_mouse_action().click_right(*gui_, x, y);
1342  if(a) {
1343  perform_refresh_delete(std::move(a), true);
1344  set_button_state();
1345  }
1346  return false;
1347 }
1348 
1349 void editor_controller::right_drag_end(int x, int y, const bool /*browse*/)
1350 {
1351  auto a = get_mouse_action().drag_end_right(*gui_, x, y);
1352  perform_delete(std::move(a));
1353 }
1354 
1355 void editor_controller::right_mouse_up(int x, int y, const bool browse)
1356 {
1357  // Call base method to handle context menus.
1358  mouse_handler_base::right_mouse_up(x, y, browse);
1359 
1360  auto a = get_mouse_action().up_right(*gui_, x, y);
1361  if(a) {
1362  perform_delete(std::move(a));
1363  set_button_state();
1364  }
1365  toolkit_->set_mouseover_overlay();
1366  context_manager_->refresh_after_action();
1367 }
1368 
1370 {
1371  const map_location& loc = gui().mouseover_hex();
1372  if (get_current_map_context().map().on_board(loc) == false)
1373  return;
1374 
1377 }
1378 
1379 void editor_controller::process_keyup_event(const SDL_Event& event)
1380 {
1381  auto a = get_mouse_action().key_event(gui(), event);
1382  perform_refresh_delete(std::move(a));
1383  toolkit_->set_mouseover_overlay();
1384 }
1385 
1387  return this;
1388 }
1389 
1391 {
1393 }
1394 
1396 {
1398 }
1399 
1401 {
1403 }
1404 
1406 {
1408 }
1409 
1411 {
1412  return toolkit_->get_palette_manager()->active_palette().action_pressed();
1413 }
1414 
1415 } //end namespace editor
virtual bool in_context_menu(hotkey::HOTKEY_COMMAND command) const
const map_location & mouseover_hex() const
Definition: display.hpp:287
Randomize terrain in an area.
Definition: action.hpp:397
virtual std::unique_ptr< editor_action > drag_end_left(editor_display &disp, int x, int y)
The end of dragging.
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
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:161
void set_draw_num_of_bitmaps(bool value)
Setter for the terrain code debug overlay on tiles.
Definition: display.hpp:367
void set_scroll_down(bool on)
unit_iterator end()
Definition: map.hpp:428
bool minimap_draw_units()
Definition: general.cpp:809
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:114
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:362
void set(CURSOR_TYPE type)
Use the default parameter to reset cursors.
Definition: cursor.cpp:175
void save_map() override
Save the map, open dialog if not named yet.
void init_tods(const game_config_view &game_config)
init the available time-of-day settings
void export_selection_coords()
Export the WML-compatible list of selected tiles to the system clipboard.
int dummy
Definition: lstrlib.cpp:1347
virtual std::unique_ptr< editor_action > click_right(editor_display &disp, int x, int y)=0
A click, possibly the beginning of a drag.
game_classification * classification
Definition: resources.cpp:34
void show_terrain_description(const terrain_type &t)
Definition: help.cpp:62
void do_screenshot(const std::string &screenshot_filename="map_screenshot.bmp")
Takes a screenshot.
void perform_refresh_delete(std::unique_ptr< editor_action > action, bool drag_part=false)
Peform an action on the current map_context, then refresh the display and delete the pointer...
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:597
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
config_array_view child_range(config_key_type key) const
bool minimap_movement_coding()
Definition: general.cpp:789
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:356
void new_area(const std::set< map_location > &area)
void show_unit_list(display &gui)
Definition: unit_list.cpp:197
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:2420
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:1080
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.
#define SCOPE_ED
const std::vector< std::string > items
void play_music_once(const std::string &file)
Definition: sound.cpp:602
static std::string _(const char *str)
Definition: gettext.hpp:92
The editor_controller class contains the mouse and keyboard event handling routines for the editor...
bool draw_terrain_codes()
Definition: editor.cpp:36
virtual std::unique_ptr< editor_action > up_right(editor_display &disp, int x, int y)
void partial_undo()
Un-does a single step from a undo action chain.
virtual std::unique_ptr< editor_action > drag_end_right(editor_display &disp, int x, int y)
Keyboard shortcuts for game actions.
Unit and team statistics.
void remove_area(int index)
void flush_cache()
Purges all image caches.
Definition: picture.cpp:221
bool modified() const
void perform_delete(std::unique_ptr< editor_action > action)
Perform an action, then delete the action object.
#define b
#define WRN_ED
bool minimap_draw_villages()
Definition: general.cpp:819
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.
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 std::unique_ptr< 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:148
surface screenshot(bool map_screenshot=false)
Capture a (map-)screenshot into a surface.
Definition: display.cpp:788
virtual bool has_context_menu() const
bool on_board_with_border(const map_location &loc) const
Definition: map.cpp:387
void remove_side()
removes the last side from the scenario
Definition: map_context.hpp:97
Implements a quit confirmation dialog.
filter_context * filter_con
Definition: resources.cpp:23
bool valid() const
Definition: location.hpp:88
void set_draw_coordinates(bool value)
Setter for the x,y debug overlay on tiles.
Definition: display.hpp:357
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)
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:182
void init_music(const game_config_view &game_config)
init background music for the editor
editor_action * last_undo_action()
bool is_pure_map() const
bool draw_hex_coordinates()
Definition: editor.cpp:44
void create_buttons()
Definition: display.cpp:877
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:35
void invalidate_all()
Function to invalidate all tiles.
Definition: display.cpp:3015
Paint the same terrain on a number of locations on the map.
Definition: action.hpp:264
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:37
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:309
void recalculate_labels()
Definition: label.cpp:244
void set_starting_position_labels(display &disp)
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:934
bool everything_selected() const
Definition: editor_map.cpp:205
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:1626
Game configuration data as global variables.
Definition: build_info.cpp:57
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:124
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.
Internal representation of music tracks.
std::string name
Definition: sdl_ttf.cpp:70
virtual std::vector< std::string > additional_actions_pressed() override
void set_scroll_right(bool on)
bool empty() const
Definition: map.hpp:445
CURSOR_TYPE get()
Definition: cursor.cpp:215
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:39
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:100
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.
virtual std::unique_ptr< editor_action > up_left(editor_display &disp, int x, int y)
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:519
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:33
const game_config_view & game_config_
bool minimap_draw_terrain()
Definition: general.cpp:829
virtual const editor_map & map() const override
Const map accessor.
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)
virtual std::unique_ptr< editor_action > click_left(editor_display &disp, int x, int y)=0
A click, possibly the beginning of a drag.
void replace_local_schedule(const std::vector< time_of_day > &schedule)
Replace the [time]s of the currently active area.
virtual std::unique_ptr< editor_action > drag_left(editor_display &disp, int x, int y, bool &partial, editor_action *last_undo)
Drag operation.
Container associating units to locations.
Definition: map.hpp:97
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 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.
There are still moves and/or attacks possible, but the unit doesn&#39;t fit in the "unmoved" status...
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:59
mock_char c
void scroll_down(bool on) override
virtual std::unique_ptr< editor_action > drag_right(editor_display &disp, int x, int y, bool &partial, editor_action *last_undo)
Drag operation.
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.
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:799