1 // Copyright (C) 2007 Ole Laursen
2 // Copyright (C) 2007, 2008, 2009 Ben Asselstine
4 // This program is free software; you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation; either version 3 of the License, or
7 // (at your option) any later version.
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Library General Public License for more details.
14 // You should have received a copy of the GNU General Public License
15 // along with this program; if not, write to the Free Software
16 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 #include <SDL_video.h>
25 #include <sigc++/functors/mem_fun.h>
26 #include <sigc++/functors/ptr_fun.h>
29 #include "main-window.h"
31 #include "image-helpers.h"
32 #include "input-helpers.h"
33 #include "error-utils.h"
35 #include "ucompose.hpp"
37 #include "tilesetlist.h"
42 #include "GraphicsCache.h"
44 #include "GameScenario.h"
45 #include "CreateScenarioRandomize.h"
46 #include "armysetlist.h"
48 #include "playerlist.h"
49 #include "shieldsetlist.h"
50 #include "citysetlist.h"
57 #include "templelist.h"
61 #include "signpostlist.h"
65 #include "bridgelist.h"
69 #include "MapGenerator.h"
72 #include "glade-helpers.h"
73 #include "editorbigmap.h"
75 #include "signpost-editor-dialog.h"
76 #include "temple-editor-dialog.h"
77 #include "ruin-editor-dialog.h"
78 #include "stack-editor-dialog.h"
79 #include "players-dialog.h"
80 #include "city-editor-dialog.h"
81 #include "map-info-dialog.h"
82 #include "new-map-dialog.h"
83 #include "switch-sets-dialog.h"
84 #include "itemlist-dialog.h"
85 #include "rewardlist-dialog.h"
86 #include "timed-message-dialog.h"
87 #include "backpack-editor-dialog.h"
88 #include "MapBackpack.h"
91 MainWindow::MainWindow(std::string load_filename)
93 d_load_filename = load_filename;
97 d_create_scenario_names = NULL;
99 Glib::RefPtr<Gtk::Builder> xml
100 = Gtk::Builder::create_from_file(get_glade_path() + "/main-window.ui");
102 xml->get_widget("window", window);
103 window->set_icon_from_file(File::getMiscFile("various/tileset_icon.png"));
105 window->signal_delete_event().connect(
106 sigc::mem_fun(*this, &MainWindow::on_delete_event));
109 xml->get_widget("bigmap_drawingarea", bigmap_drawingarea);
110 //bigmap_drawingarea->set_double_buffered(false);
111 //bigmap_drawingarea->set_app_paintable(true);
112 bigmap_drawingarea->signal_expose_event().connect
113 (sigc::mem_fun(*this, &MainWindow::on_bigmap_exposed));
114 bigmap_drawingarea->signal_size_allocate().connect
115 (sigc::mem_fun(*this, &MainWindow::on_bigmap_surface_changed));
116 xml->get_widget("bigmap_eventbox", bigmap_eventbox);
118 bigmap_eventbox->add_events(Gdk::BUTTON_PRESS_MASK |
119 Gdk::BUTTON_RELEASE_MASK |
120 Gdk::POINTER_MOTION_MASK |
121 Gdk::KEY_PRESS_MASK);
122 bigmap_eventbox->signal_button_press_event().connect(
123 sigc::mem_fun(*this, &MainWindow::on_bigmap_mouse_button_event));
124 bigmap_eventbox->signal_button_release_event().connect(
125 sigc::mem_fun(*this, &MainWindow::on_bigmap_mouse_button_event));
126 bigmap_eventbox->signal_motion_notify_event().connect(
127 sigc::mem_fun(*this, &MainWindow::on_bigmap_mouse_motion_event));
128 bigmap_eventbox->signal_key_press_event().connect(
129 sigc::mem_fun(*this, &MainWindow::on_bigmap_key_event));
130 bigmap_eventbox->signal_leave_notify_event().connect(
131 sigc::mem_fun(*this, &MainWindow::on_bigmap_leave_event));
132 xml->get_widget("map_drawingarea", map_drawingarea);
133 map_drawingarea->signal_expose_event().connect
134 (sigc::mem_fun(*this, &MainWindow::on_smallmap_exposed));
135 Gtk::EventBox *map_eventbox;
136 xml->get_widget("map_eventbox", map_eventbox);
137 map_eventbox->add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK |
138 Gdk::POINTER_MOTION_MASK);
139 map_eventbox->signal_button_press_event().connect(
140 sigc::mem_fun(*this, &MainWindow::on_smallmap_mouse_button_event));
141 map_eventbox->signal_button_release_event().connect(
142 sigc::mem_fun(*this, &MainWindow::on_smallmap_mouse_button_event));
143 map_eventbox->signal_motion_notify_event().connect(
144 sigc::mem_fun(*this, &MainWindow::on_smallmap_mouse_motion_event));
146 xml->get_widget("terrain_tile_style_hbox", terrain_tile_style_hbox);
148 // setup pointer radiobuttons
149 xml->get_widget("terrain_type_table", terrain_type_table);
151 setup_pointer_radiobutton(xml, "pointer", "button_selector",
152 EditorBigMap::POINTER, 1);
153 setup_pointer_radiobutton(xml, "draw_1", "button_1x1",
154 EditorBigMap::TERRAIN, 1);
155 setup_pointer_radiobutton(xml, "draw_2", "button_2x2",
156 EditorBigMap::TERRAIN, 2);
157 setup_pointer_radiobutton(xml, "draw_3", "button_3x3",
158 EditorBigMap::TERRAIN, 3);
159 setup_pointer_radiobutton(xml, "draw_6", "button_6x6",
160 EditorBigMap::TERRAIN, 6);
161 setup_pointer_radiobutton(xml, "draw_stack", "button_stack",
162 EditorBigMap::STACK, 1);
163 setup_pointer_radiobutton(xml, "draw_ruin", "button_ruin",
164 EditorBigMap::RUIN, 1);
165 setup_pointer_radiobutton(xml, "draw_signpost", "button_signpost",
166 EditorBigMap::SIGNPOST, 1);
167 setup_pointer_radiobutton(xml, "draw_temple", "button_temple",
168 EditorBigMap::TEMPLE, 1);
169 setup_pointer_radiobutton(xml, "draw_road", "button_road",
170 EditorBigMap::ROAD, 1);
171 setup_pointer_radiobutton(xml, "draw_city", "button_castle",
172 EditorBigMap::CITY, 1);
173 setup_pointer_radiobutton(xml, "erase", "button_erase",
174 EditorBigMap::ERASE, 1);
175 setup_pointer_radiobutton(xml, "move", "button_move",
176 EditorBigMap::MOVE, 1);
177 setup_pointer_radiobutton(xml, "draw_port", "button_port",
178 EditorBigMap::PORT, 1);
179 setup_pointer_radiobutton(xml, "draw_bridge", "button_bridge",
180 EditorBigMap::BRIDGE, 1);
181 setup_pointer_radiobutton(xml, "draw_bag", "button_bag",
182 EditorBigMap::BAG, 1);
184 xml->get_widget("players_hbox", players_hbox);
185 on_pointer_radiobutton_toggled();
187 xml->get_widget("mouse_position_label", mouse_position_label);
190 // connect callbacks for the menu
191 xml->get_widget("new_map_menuitem", new_map_menuitem);
192 new_map_menuitem->signal_activate().connect
193 (sigc::mem_fun(this, &MainWindow::on_new_map_activated));
194 xml->get_widget("load_map_menuitem", load_map_menuitem);
195 load_map_menuitem->signal_activate().connect
196 (sigc::mem_fun(this, &MainWindow::on_load_map_activated));
197 xml->get_widget("save_map_menuitem", save_map_menuitem);
198 save_map_menuitem->signal_activate().connect
199 (sigc::mem_fun(this, &MainWindow::on_save_map_activated));
200 xml->get_widget("save_map_as_menuitem", save_map_as_menuitem);
201 save_map_as_menuitem->signal_activate().connect
202 (sigc::mem_fun(this, &MainWindow::on_save_map_as_activated));
203 xml->get_widget("import_map_from_sav_menuitem", import_map_from_sav_menuitem);
204 import_map_from_sav_menuitem->signal_activate().connect
205 (sigc::mem_fun(this, &MainWindow::on_import_map_activated));
206 xml->get_widget("export_as_bitmap_menuitem", export_as_bitmap_menuitem);
207 export_as_bitmap_menuitem->signal_activate().connect
208 (sigc::mem_fun(this, &MainWindow::on_export_as_bitmap_activated));
209 xml->get_widget("export_as_bitmap_no_game_objects_menuitem",
210 export_as_bitmap_no_game_objects_menuitem);
211 export_as_bitmap_no_game_objects_menuitem->signal_activate().connect
212 (sigc::mem_fun(this, &MainWindow::on_export_as_bitmap_no_game_objects_activated));
213 xml->get_widget("validate_menuitem", validate_menuitem);
214 validate_menuitem->signal_activate().connect
215 (sigc::mem_fun(this, &MainWindow::on_validate_activated));
216 xml->get_widget("quit_menuitem", quit_menuitem);
217 quit_menuitem->signal_activate().connect
218 (sigc::mem_fun(this, &MainWindow::on_quit_activated));
220 xml->get_widget("edit_players_menuitem", edit_players_menuitem);
221 edit_players_menuitem->signal_activate().connect
222 (sigc::mem_fun(this, &MainWindow::on_edit_players_activated));
223 xml->get_widget("edit_map_info_menuitem", edit_map_info_menuitem);
224 edit_map_info_menuitem->signal_activate().connect
225 (sigc::mem_fun(this, &MainWindow::on_edit_map_info_activated));
227 xml->get_widget("fullscreen_menuitem", fullscreen_menuitem);
228 fullscreen_menuitem->signal_activate().connect
229 (sigc::mem_fun(this, &MainWindow::on_fullscreen_activated));
230 xml->get_widget("toggle_tile_graphics_menuitem", toggle_tile_graphics_menuitem);
231 toggle_tile_graphics_menuitem->signal_activate().connect
232 (sigc::mem_fun(this, &MainWindow::on_tile_graphics_toggled));
233 xml->get_widget("toggle_grid_menuitem", toggle_grid_menuitem);
234 toggle_grid_menuitem->signal_activate().connect
235 (sigc::mem_fun(this, &MainWindow::on_grid_toggled));
236 xml->get_widget("smooth_map_menuitem", smooth_map_menuitem);
237 smooth_map_menuitem->signal_activate().connect
238 (sigc::mem_fun(this, &MainWindow::on_smooth_map_activated));
239 xml->get_widget("switch_sets_menuitem", switch_sets_menuitem);
240 switch_sets_menuitem->signal_activate().connect
241 (sigc::mem_fun(this, &MainWindow::on_switch_sets_activated));
242 xml->get_widget("smooth_screen_menuitem", smooth_screen_menuitem);
243 smooth_screen_menuitem->signal_activate().connect
244 (sigc::mem_fun (this, &MainWindow::on_smooth_screen_activated));
245 xml->get_widget("edit_items_menuitem", edit_items_menuitem);
246 edit_items_menuitem->signal_activate().connect
247 (sigc::mem_fun(this, &MainWindow::on_edit_items_activated));
248 xml->get_widget("edit_rewards_menuitem", edit_rewards_menuitem);
249 edit_rewards_menuitem->signal_activate().connect
250 (sigc::mem_fun(this, &MainWindow::on_edit_rewards_activated));
251 xml->get_widget ("random_all_cities_menuitem", random_all_cities_menuitem);
252 random_all_cities_menuitem->signal_activate().connect
253 (sigc::mem_fun(this, &MainWindow::on_random_all_cities_activated));
254 xml->get_widget ("random_unnamed_cities_menuitem",
255 random_unnamed_cities_menuitem);
256 random_unnamed_cities_menuitem->signal_activate().connect
257 (sigc::mem_fun(this, &MainWindow::on_random_unnamed_cities_activated));
258 xml->get_widget ("random_all_ruins_menuitem", random_all_ruins_menuitem);
259 random_all_ruins_menuitem->signal_activate().connect
260 (sigc::mem_fun(this, &MainWindow::on_random_all_ruins_activated));
261 xml->get_widget ("random_unnamed_ruins_menuitem",
262 random_unnamed_ruins_menuitem);
263 random_unnamed_ruins_menuitem->signal_activate().connect
264 (sigc::mem_fun(this, &MainWindow::on_random_unnamed_ruins_activated));
265 xml->get_widget ("random_all_temples_menuitem",
266 random_all_temples_menuitem);
267 random_all_temples_menuitem->signal_activate().connect
268 (sigc::mem_fun(this, &MainWindow::on_random_all_temples_activated));
269 xml->get_widget ("random_unnamed_temples_menuitem",
270 random_unnamed_temples_menuitem);
271 random_unnamed_temples_menuitem->signal_activate().connect
272 (sigc::mem_fun(this, &MainWindow::on_random_unnamed_temples_activated));
273 xml->get_widget ("random_all_signs_menuitem",
274 random_all_signs_menuitem);
275 random_all_signs_menuitem->signal_activate().connect
276 (sigc::mem_fun(this, &MainWindow::on_random_all_signs_activated));
277 xml->get_widget ("random_unnamed_signs_menuitem",
278 random_unnamed_signs_menuitem);
279 random_unnamed_signs_menuitem->signal_activate().connect
280 (sigc::mem_fun(this, &MainWindow::on_random_unnamed_signs_activated));
281 xml->get_widget ("help_about_menuitem", help_about_menuitem);
282 help_about_menuitem->signal_activate().connect
283 (sigc::mem_fun(this, &MainWindow::on_help_about_activated));
286 MainWindow::~MainWindow()
290 delete game_scenario;
291 delete d_create_scenario_names;
295 void MainWindow::setup_pointer_radiobutton(Glib::RefPtr<Gtk::Builder> xml,
297 std::string image_file,
298 EditorBigMap::Pointer pointer,
302 xml->get_widget(prefix + "_radiobutton", item.button);
303 if (prefix == "pointer")
304 pointer_radiobutton = item.button;
305 item.button->signal_toggled().connect(
306 sigc::mem_fun(this, &MainWindow::on_pointer_radiobutton_toggled));
307 item.pointer = pointer;
309 pointer_items.push_back(item);
312 xml->get_widget(prefix + "_image", image);
313 image->property_file() = File::getEditorFile(image_file);
314 item.button->property_draw_indicator() = false;
317 void MainWindow::setup_terrain_radiobuttons()
319 // get rid of old ones
320 terrain_type_table->children().erase(terrain_type_table->children().begin(),
321 terrain_type_table->children().end());
323 // then add new ones from the tile set
324 Tileset *tset = GameMap::getInstance()->getTileset();
325 Gtk::RadioButton::Group group;
326 bool group_set = false;
327 const int no_columns = 6;
328 for (unsigned int i = 0; i < tset->size(); ++i)
330 Tile *tile = (*tset)[i];
332 item.button = manage(new Gtk::RadioButton);
334 item.button->set_group(group);
337 group = item.button->get_group();
340 item.button->property_draw_indicator() = false;
342 int row = i / no_columns, column = i % no_columns;
344 terrain_type_table->attach(*item.button, column, column + 1,
345 row, row + 1, Gtk::SHRINK);
346 item.button->signal_toggled().connect(
347 sigc::mem_fun(this, &MainWindow::on_terrain_radiobutton_toggled));
349 Glib::RefPtr<Gdk::Pixbuf> pic;
350 PixMask *pix = (*(*(*tile).begin())->begin())->getImage()->copy();
351 PixMask::scale(pix, 20, 20);
352 item.button->add(*manage(new Gtk::Image(pix->to_pixbuf())));
355 item.terrain = tile->getType();
356 terrain_items.push_back(item);
359 terrain_type_table->show_all();
362 void MainWindow::show()
364 bigmap_drawingarea->show_all();
366 on_bigmap_surface_changed(bigmap_drawingarea->get_allocation());
369 void MainWindow::on_bigmap_surface_changed(Gtk::Allocation box)
373 static Gtk::Allocation last_box = Gtk::Allocation(0,0,1,1);
375 if (box.get_width() != last_box.get_width() || box.get_height() != last_box.get_height())
377 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
382 bool MainWindow::on_bigmap_exposed(GdkEventExpose *event)
384 Glib::RefPtr<Gdk::Window> window = bigmap_drawingarea->get_window();
387 Glib::RefPtr<Gdk::Pixmap> surface = bigmap->get_surface();
388 window->draw_drawable(bigmap_drawingarea->get_style()->get_white_gc(),
389 surface, event->area.x, event->area.y,
390 event->area.x, event->area.y,
391 event->area.width, event->area.height);
395 bool MainWindow::on_smallmap_exposed(GdkEventExpose *event)
397 Glib::RefPtr<Gdk::Window> window = map_drawingarea->get_window();
400 Glib::RefPtr<Gdk::Pixmap> surface = smallmap->get_surface();
401 window->draw_drawable(map_drawingarea->get_style()->get_white_gc(),
402 surface, event->area.x, event->area.y,
403 event->area.x, event->area.y,
404 event->area.width, event->area.height);
409 void MainWindow::init()
411 Armysetlist::getInstance()->instantiateImages();
412 Tilesetlist::getInstance()->instantiateImages();
413 Shieldsetlist::getInstance()->instantiateImages();
414 Citysetlist::getInstance()->instantiateImages();
416 Playerlist::getInstance()->setActiveplayer(Playerlist::getInstance()->getNeutral());
420 void MainWindow::hide()
425 bool MainWindow::on_delete_event(GdkEventAny *e)
430 void MainWindow::show_initial_map()
432 if (d_load_filename.empty() == false)
438 delete game_scenario;
439 current_save_filename = d_load_filename;
440 game_scenario = new GameScenario(current_save_filename, broken);
441 if (d_create_scenario_names)
442 delete d_create_scenario_names;
443 d_create_scenario_names = new CreateScenarioRandomize();
447 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
448 setup_terrain_radiobuttons();
449 remove_tile_style_buttons();
450 setup_tile_style_buttons(Tile::GRASS);
454 d_load_filename = "";
460 set_filled_map(112, 156, Tile::WATER, "default", "default", "default",
462 setup_terrain_radiobuttons();
463 remove_tile_style_buttons();
464 setup_tile_style_buttons(Tile::GRASS);
468 void MainWindow::set_filled_map(int width, int height, int fill_style, std::string tileset, std::string shieldset, std::string cityset, std::string armyset)
474 GameMap::deleteInstance();
475 GameMap::setWidth(width);
476 GameMap::setHeight(height);
477 GameMap::getInstance(tileset, shieldset, cityset);
478 Itemlist::createStandardInstance();
481 delete game_scenario;
483 game_scenario = new GameScenario(_("Untitled"), _("No description"), true);
484 if (d_create_scenario_names)
485 delete d_create_scenario_names;
486 d_create_scenario_names = new CreateScenarioRandomize();
487 //zip past the player IDs (+1 for neutral)
488 for (unsigned int i = 0; i < MAX_PLAYERS + 1; i++)
489 fl_counter->getNextId();
492 // ...however we need to do some of the setup by hand. We need to create a
493 // neutral player to give cities a player upon creation...
495 Armysetlist::getInstance()->getArmyset(armyset)->getId();
496 Shieldsetlist *ssl = Shieldsetlist::getInstance();
497 Shieldset *ss = ssl->getShieldset(shieldset);
498 std::string name = d_create_scenario_names->getPlayerName(Shield::NEUTRAL);
499 Player* neutral = new AI_Dummy(name, armyset_id,
500 ssl->getColor(ss->getId(), MAX_PLAYERS),
501 width, height, MAX_PLAYERS);
502 neutral->setType(Player::AI_DUMMY);
503 Playerlist::getInstance()->add(neutral);
504 Playerlist::getInstance()->setNeutral(neutral);
505 Playerlist::getInstance()->nextPlayer();
507 // fill the map with tile type
508 Tileset* tset = GameMap::getInstance()->getTileset();
509 for (unsigned int i = 0; i < tset->size(); ++i)
511 if ((*tset)[i]->getType() == fill_style)
513 GameMap::getInstance()->fill(i);
521 void MainWindow::set_random_map(int width, int height,
522 int grass, int water, int swamp, int forest,
523 int hills, int mountains,
524 int cities, int ruins, int temples,
525 int signposts, std::string tileset,
526 std::string shieldset, std::string cityset,
531 GameMap::deleteInstance();
532 GameMap::setWidth(width);
533 GameMap::setHeight(height);
534 GameMap::getInstance(tileset, shieldset, cityset);
536 //zip past the player IDs
539 fl_counter = new FL_Counter(MAX_PLAYERS + 1);
541 // We need to create a neutral player to give cities a player upon
544 Armysetlist::getInstance()->getArmyset(armyset)->getId();
545 Citysetlist::getInstance();
546 Shieldsetlist *ssl = Shieldsetlist::getInstance();
547 Shieldset *ss = ssl->getShieldset(shieldset);
548 std::string name = d_create_scenario_names->getPlayerName(Shield::NEUTRAL);
549 Player* neutral = new AI_Dummy(name, armyset_id,
550 ssl->getColor(ss->getId(), MAX_PLAYERS),
551 width, height, MAX_PLAYERS);
552 neutral->setType(Player::AI_DUMMY);
553 Playerlist::getInstance()->add(neutral);
554 Playerlist::getInstance()->setNeutral(neutral);
555 Playerlist::getInstance()->nextPlayer();
557 // create a random map
560 // first, fill the generator with data
561 gen.setNoCities(cities);
562 gen.setNoRuins(ruins);
563 gen.setNoTemples(temples);
564 gen.setNoSignposts(signposts);
566 // if sum > 100 (percent), divide everything by a factor, the numeric error
567 // is said to be grass
568 int sum = grass + water + forest + swamp + hills + mountains;
572 double factor = 100 / static_cast<double>(sum);
573 water = static_cast<int>(water / factor);
574 forest = static_cast<int>(forest / factor);
575 swamp = static_cast<int>(swamp / factor);
576 hills = static_cast<int>(hills / factor);
577 mountains = static_cast<int>(mountains / factor);
580 gen.setPercentages(water, forest, swamp, hills, mountains);
582 gen.setCityset(GameMap::getInstance()->getCityset());
583 gen.makeMap(width, height, false);
584 GameMap::deleteInstance();
585 GameMap::setWidth(width);
586 GameMap::setHeight(height);
587 GameMap::getInstance(tileset, shieldset, cityset);
588 GameMap::getInstance()->fill(&gen);
590 Itemlist::createStandardInstance();
593 delete game_scenario;
594 game_scenario = new GameScenario(_("Untitled"), _("No description"), true);
595 if (d_create_scenario_names)
596 delete d_create_scenario_names;
597 d_create_scenario_names = new CreateScenarioRandomize();
599 Cityset *cs = Citysetlist::getInstance()->getCityset(cityset);
600 // now fill the lists
601 const Maptile::Building* build = gen.getBuildings(width, height);
602 for (int j = 0; j < height; j++)
603 for (int i = 0; i < width; i++)
604 switch(build[j * width + i])
607 Citylist::getInstance()->add
608 (new City(Vector<int>(i,j), cs->getCityTileWidth()));
609 (*Citylist::getInstance()->rbegin())->setOwner(
610 Playerlist::getInstance()->getNeutral());
612 case Maptile::TEMPLE:
613 Templelist::getInstance()->add
614 (new Temple(Vector<int>(i,j), cs->getTempleTileWidth()));
617 Ruinlist::getInstance()->add
618 (new Ruin(Vector<int>(i,j), cs->getRuinTileWidth()));
620 case Maptile::SIGNPOST:
621 Signpostlist::getInstance()->add(new Signpost(Vector<int>(i,j)));
624 Roadlist::getInstance()->add(new Road(Vector<int>(i,j)));
626 case Maptile::BRIDGE:
627 Bridgelist::getInstance()->add(new Bridge(Vector<int>(i,j)));
630 Portlist::getInstance()->add(new Port(Vector<int>(i,j)));
639 void MainWindow::clear_map_state()
653 delete game_scenario;
654 game_scenario = NULL;
656 if (d_create_scenario_names)
658 delete d_create_scenario_names;
659 d_create_scenario_names = NULL;
661 GraphicsCache::deleteInstance();
664 void MainWindow::init_map_state()
666 pointer_radiobutton->set_active();
671 bool MainWindow::on_bigmap_mouse_button_event(GdkEventButton *e)
673 if (e->type != GDK_BUTTON_PRESS && e->type != GDK_BUTTON_RELEASE)
674 return true; // useless event
678 button_event = e; // save it for later use
679 bigmap->mouse_button_event(to_input_event(e));
681 smallmap->draw(Playerlist::getActiveplayer());
688 bool MainWindow::on_bigmap_mouse_motion_event(GdkEventMotion *e)
690 static guint prev = 0;
693 guint delta = e->time - prev;
694 if (delta > 40 || delta < 0)
696 bigmap->mouse_motion_event(to_input_event(e));
704 bool MainWindow::on_bigmap_key_event(GdkEventKey *e)
709 bigmap->key_press_event(k);
716 bool MainWindow::on_bigmap_leave_event(GdkEventCrossing *e)
720 bigmap->mouse_leave_event();
726 bool MainWindow::on_smallmap_mouse_button_event(GdkEventButton *e)
728 if (e->type != GDK_BUTTON_PRESS && e->type != GDK_BUTTON_RELEASE)
729 return true; // useless event
732 smallmap->mouse_button_event(to_input_event(e));
737 bool MainWindow::on_smallmap_mouse_motion_event(GdkEventMotion *e)
739 static guint prev = 0;
742 guint delta = e->time - prev;
743 if (delta > 100 || delta < 0)
745 smallmap->mouse_motion_event(to_input_event(e));
753 void MainWindow::on_new_map_activated()
755 current_save_filename = "";
758 d.set_parent_window(*window);
763 if (d.map.fill_style == -1)
764 set_random_map(d.map.width, d.map.height,
765 d.map.grass, d.map.water, d.map.swamp, d.map.forest,
766 d.map.hills, d.map.mountains,
767 d.map.cities, d.map.ruins, d.map.temples,
768 d.map.signposts, d.map.tileset,
769 d.map.shieldset, d.map.cityset, d.map.armyset);
771 set_filled_map(d.map.width, d.map.height, d.map.fill_style,
772 d.map.tileset, d.map.shieldset, d.map.cityset,
778 void MainWindow::on_load_map_activated()
780 Gtk::FileChooserDialog chooser(*window, _("Choose Map to Load"));
781 Gtk::FileFilter sav_filter;
782 sav_filter.add_pattern("*.map");
783 chooser.set_filter(sav_filter);
784 chooser.set_current_folder(File::getUserMapDir());
786 chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
787 chooser.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
788 chooser.set_default_response(Gtk::RESPONSE_ACCEPT);
791 int res = chooser.run();
793 if (res == Gtk::RESPONSE_ACCEPT)
795 current_save_filename = chooser.get_filename();
802 delete game_scenario;
803 game_scenario = new GameScenario(current_save_filename, broken);
804 if (d_create_scenario_names)
805 delete d_create_scenario_names;
806 d_create_scenario_names = new CreateScenarioRandomize();
810 show_error(String::ucompose(_("Could not load map %1."),
811 current_save_filename));
812 current_save_filename = "";
817 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
821 void MainWindow::on_save_map_activated()
823 if (current_save_filename.empty())
824 on_save_map_as_activated();
827 needs_saving = false;
828 bool success = game_scenario->saveGame(current_save_filename, "map");
830 show_error(_("Map was not saved!"));
834 void MainWindow::on_export_as_bitmap_activated()
836 Gtk::FileChooserDialog chooser(*window, _("Choose a Name"),
837 Gtk::FILE_CHOOSER_ACTION_SAVE);
838 Gtk::FileFilter sav_filter;
839 sav_filter.add_pattern("*.png");
840 chooser.set_filter(sav_filter);
841 chooser.set_current_folder(Glib::get_home_dir());
842 chooser.set_do_overwrite_confirmation();
844 chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
845 chooser.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
846 chooser.set_default_response(Gtk::RESPONSE_ACCEPT);
849 int res = chooser.run();
851 if (res == Gtk::RESPONSE_ACCEPT)
853 current_save_filename = chooser.get_filename();
856 bool success = bigmap->saveAsBitmap(current_save_filename);
858 show_error(_("Map was not exported!"));
862 void MainWindow::on_export_as_bitmap_no_game_objects_activated()
864 Gtk::FileChooserDialog chooser(*window, _("Choose a Name"),
865 Gtk::FILE_CHOOSER_ACTION_SAVE);
866 Gtk::FileFilter sav_filter;
867 sav_filter.add_pattern("*.png");
868 chooser.set_filter(sav_filter);
869 chooser.set_current_folder(Glib::get_home_dir());
870 chooser.set_do_overwrite_confirmation();
872 chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
873 chooser.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
874 chooser.set_default_response(Gtk::RESPONSE_ACCEPT);
877 int res = chooser.run();
879 if (res == Gtk::RESPONSE_ACCEPT)
881 current_save_filename = chooser.get_filename();
884 bool success = bigmap->saveUnderlyingMapAsBitmap(current_save_filename);
886 show_error(_("Map was not exported!"));
890 void MainWindow::on_save_map_as_activated()
892 Gtk::FileChooserDialog chooser(*window, _("Choose a Name"),
893 Gtk::FILE_CHOOSER_ACTION_SAVE);
894 Gtk::FileFilter sav_filter;
895 sav_filter.add_pattern("*.map");
896 chooser.set_filter(sav_filter);
897 chooser.set_current_folder(File::getUserMapDir());
899 chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
900 chooser.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
901 chooser.set_default_response(Gtk::RESPONSE_ACCEPT);
904 int res = chooser.run();
906 if (res == Gtk::RESPONSE_ACCEPT)
908 current_save_filename = chooser.get_filename();
911 bool success = game_scenario->saveGame(current_save_filename, "map");
913 show_error(_("Map was not saved!"));
914 needs_saving = false;
918 bool MainWindow::quit()
923 Glib::RefPtr<Gtk::Builder> xml
924 = Gtk::Builder::create_from_file(get_glade_path() +
925 "/editor-quit-dialog.ui");
926 xml->get_widget("dialog", dialog);
927 dialog->set_transient_for(*window);
928 int response = dialog->run();
932 if (response == Gtk::RESPONSE_CANCEL) //we don't want to quit
935 else if (response == Gtk::RESPONSE_ACCEPT) // save and quit
936 on_save_map_activated();
937 //else if (Response == Gtk::CLOSE) // don't save just quit
945 void MainWindow::on_quit_activated()
950 void MainWindow::on_edit_players_activated()
952 PlayersDialog d(d_create_scenario_names, d_width, d_height);
953 d.set_parent_window(*window);
954 Player *active = Playerlist::getActiveplayer();
955 int response = d.run();
956 if (response == Gtk::RESPONSE_ACCEPT)
958 if (Playerlist::getInstance()->getPlayer(active->getId()))
959 Playerlist::getInstance()->setActiveplayer(active);
965 void MainWindow::on_edit_map_info_activated()
967 MapInfoDialog d(game_scenario);
968 d.set_parent_window(*window);
969 int response = d.run();
970 if (response == Gtk::RESPONSE_ACCEPT)
974 void MainWindow::on_fullscreen_activated()
976 if (fullscreen_menuitem->get_active())
977 window->fullscreen();
979 window->unfullscreen();
982 void MainWindow::on_tile_graphics_toggled()
984 bigmap->toggleViewStylesOrTypes();
985 bigmap->draw(Playerlist::getViewingplayer());
987 void MainWindow::on_grid_toggled()
989 bigmap->toggle_grid();
993 void MainWindow::remove_tile_style_buttons()
995 Glib::ListHandle<Gtk::Widget*> children =
996 terrain_tile_style_hbox->get_children();
997 if (!children.empty())
999 Glib::ListHandle<Gtk::Widget*>::iterator child = children.begin();
1000 for (; child != children.end(); child++)
1001 terrain_tile_style_hbox->remove(**child);
1003 tile_style_items.clear();
1006 void MainWindow::setup_tile_style_buttons(Tile::Type terrain)
1008 Gtk::RadioButton::Group group;
1009 //iterate through tilestyles of a certain TERRAIN tile
1010 Tileset *tileset = GameMap::getInstance()->getTileset();
1011 guint32 index = tileset->getIndex(terrain);
1012 Tile *tile = (*tileset)[index];
1016 TileStyleItem auto_item;
1017 auto_item.button = manage(new Gtk::RadioButton);
1018 terrain_tile_style_hbox->pack_start(*manage(auto_item.button),
1019 Gtk::PACK_SHRINK, 0, 0);
1020 auto_item.button->set_label(_("Auto"));
1021 auto_item.button->property_draw_indicator() = false;
1023 auto_item.button->signal_toggled().connect
1024 (sigc::mem_fun(this, &MainWindow::on_tile_style_radiobutton_toggled));
1026 auto_item.tile_style_id = -1;
1027 group = auto_item.button->get_group();
1028 tile_style_items.push_back(auto_item);
1030 for (Tile::iterator it = tile->begin(); it != tile->end(); it++)
1032 TileStyleSet *tilestyleset = *it;
1033 //loop through tile style sets
1034 for (unsigned int j = 0; j < tilestyleset->size(); j++)
1036 //now loop through the tile styles
1037 TileStyle *tilestyle = (*tilestyleset)[j];
1039 //let's make a button
1041 item.button = manage(new Gtk::RadioButton);
1042 item.button->set_group(group);
1043 item.button->property_draw_indicator() = false;
1045 terrain_tile_style_hbox->pack_start(*manage(item.button),
1046 Gtk::PACK_SHRINK, 0, 0);
1047 item.button->signal_toggled().connect
1048 (sigc::mem_fun(this,
1049 &MainWindow::on_tile_style_radiobutton_toggled));
1051 Glib::RefPtr<Gdk::Pixbuf> pic = tilestyle->getImage()->to_pixbuf();
1052 item.button->add(*manage(new Gtk::Image(pic)));
1053 item.tile_style_id = tilestyle->getId();
1055 tile_style_items.push_back(item);
1059 terrain_tile_style_hbox->show_all();
1063 void MainWindow::auto_select_appropriate_pointer()
1065 switch (get_terrain())
1069 pointer_items[1].button->set_active();
1077 Tileset *tileset = GameMap::getInstance()->getTileset();
1078 Tile *tile = (*tileset)[tileset->getIndex(get_terrain())];
1079 if (tile->consistsOnlyOfLoneAndOtherStyles())
1080 pointer_items[1].button->set_active();
1082 pointer_items[2].button->set_active();
1085 case Tile::MOUNTAIN:
1087 pointer_items[4].button->set_active();
1092 void MainWindow::on_tile_style_radiobutton_toggled()
1094 on_pointer_radiobutton_toggled();
1096 //was the first one (auto) clicked? if so, we want 1x1
1097 if (get_tile_style_id() != -1)
1098 pointer_items[1].button->set_active();
1100 auto_select_appropriate_pointer();
1103 void MainWindow::on_terrain_radiobutton_toggled()
1105 remove_tile_style_buttons();
1106 setup_tile_style_buttons(get_terrain());
1107 on_pointer_radiobutton_toggled();
1108 auto_select_appropriate_pointer();
1111 void MainWindow::on_pointer_radiobutton_toggled()
1113 EditorBigMap::Pointer pointer = EditorBigMap::POINTER;
1116 for (std::vector<PointerItem>::iterator i = pointer_items.begin(),
1117 end = pointer_items.end(); i != end; ++i)
1119 if (i->button->get_active())
1121 pointer = i->pointer;
1128 bigmap->set_pointer(pointer, size, get_terrain(),
1129 get_tile_style_id());
1130 terrain_type_table->set_sensitive(pointer == EditorBigMap::TERRAIN);
1131 terrain_tile_style_hbox->set_sensitive(pointer == EditorBigMap::TERRAIN);
1133 players_hbox->set_sensitive (pointer == EditorBigMap::STACK ||
1134 pointer == EditorBigMap::CITY);
1137 Tile::Type MainWindow::get_terrain()
1139 Tile::Type terrain = Tile::GRASS;
1140 for (std::vector<TerrainItem>::iterator i = terrain_items.begin(),
1141 end = terrain_items.end(); i != end; ++i)
1143 if (i->button->get_active())
1145 terrain = i->terrain;
1153 int MainWindow::get_tile_style_id()
1155 int tile_style_id = -1;
1156 for (std::vector<TileStyleItem>::iterator i = tile_style_items.begin(),
1157 end = tile_style_items.end(); i != end; ++i)
1159 if (i->button->get_active())
1161 tile_style_id = i->tile_style_id;
1166 return tile_style_id;
1169 void MainWindow::on_bigmap_changed(Glib::RefPtr<Gdk::Pixmap> map)
1173 map->get_size(width, height);
1174 Glib::RefPtr<Gdk::Window> window = bigmap_drawingarea->get_window();
1177 Gdk::Rectangle r = Gdk::Rectangle(0, 0, width, height);
1178 window->invalidate_rect(r, true);
1181 void MainWindow::on_smallmap_changed(Glib::RefPtr<Gdk::Pixmap> map, Gdk::Rectangle r)
1185 map->get_size(width, height);
1186 map_drawingarea->property_width_request() = width;
1187 map_drawingarea->property_height_request() = height;
1189 Glib::RefPtr<Gdk::Window> window = map_drawingarea->get_window();
1192 window->invalidate_rect(r, false);
1194 //map_image->property_pixmap() = map;
1196 //still resides at smallmap->get_surface()
1200 void MainWindow::init_maps()
1202 // init the smallmap
1205 smallmap =new SmallMap;
1207 smallmap->map_changed.connect(
1208 sigc::mem_fun(this, &MainWindow::on_smallmap_changed));
1213 bigmap = new EditorBigMap;
1214 bigmap->mouse_on_tile.connect(
1215 sigc::mem_fun(this, &MainWindow::on_mouse_on_tile));
1216 bigmap->objects_selected.connect(
1217 sigc::mem_fun(this, &MainWindow::on_objects_selected));
1218 bigmap->map_changed.connect(
1219 sigc::mem_fun(this, &MainWindow::on_bigmap_changed));
1221 // grid is on by default
1222 bigmap->toggle_grid();
1224 // connect the two maps
1225 bigmap->view_changed.connect(
1226 sigc::mem_fun(smallmap, &SmallMap::set_view));
1227 bigmap->map_tiles_changed.connect(
1228 sigc::mem_fun(smallmap, &SmallMap::redraw_tiles));
1229 smallmap->view_changed.connect(
1230 sigc::mem_fun(bigmap, &EditorBigMap::set_view));
1232 //trigger the bigmap to resize the view box in the smallmap
1233 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
1236 void MainWindow::on_mouse_on_tile(Vector<int> tile)
1239 if (tile.x > 0 && tile.y > 0)
1240 // note to translators: this is a coordinate pair (x, y)
1241 str = "<i>" + String::ucompose(_("(%1, %2)"), tile.x, tile.y) + "</i>";
1243 mouse_position_label->set_markup(str);
1246 void MainWindow::on_objects_selected(std::vector<UniquelyIdentified *> objects)
1248 assert(!objects.empty());
1250 if (objects.size() == 1)
1252 popup_dialog_for_object(objects.front());
1257 Gtk::Menu *menu = manage(new Gtk::Menu);
1258 for (std::vector<UniquelyIdentified *>::iterator i = objects.begin(), end = objects.end();
1262 if (dynamic_cast<Stack *>(*i))
1264 else if (dynamic_cast<City *>(*i))
1266 else if (dynamic_cast<Ruin *>(*i))
1268 else if (dynamic_cast<Signpost *>(*i))
1270 else if (dynamic_cast<Temple *>(*i))
1272 else if (dynamic_cast<MapBackpack*>(*i))
1275 Gtk::MenuItem *item = manage(new Gtk::MenuItem(s));
1276 item->signal_activate().connect(
1277 sigc::bind(sigc::mem_fun(this, &MainWindow::popup_dialog_for_object), *i));
1281 menu->popup(button_event->button, button_event->time);
1285 void MainWindow::popup_dialog_for_object(UniquelyIdentified *object)
1287 if (Stack *o = dynamic_cast<Stack *>(object))
1289 StackEditorDialog d(o);
1290 d.set_parent_window(*window);
1291 int response = d.run();
1292 if (response == Gtk::RESPONSE_ACCEPT)
1293 needs_saving = true;
1295 // we might have changed something visible
1298 else if (City *o = dynamic_cast<City *>(object))
1300 CityEditorDialog d(o, d_create_scenario_names);
1301 d.set_parent_window(*window);
1302 int response = d.run();
1303 if (response == Gtk::RESPONSE_ACCEPT)
1304 needs_saving = true;
1306 // we might have changed something visible
1309 else if (Ruin *o = dynamic_cast<Ruin *>(object))
1311 RuinEditorDialog d(o, d_create_scenario_names);
1312 d.set_parent_window(*window);
1313 int response = d.run();
1314 if (response == Gtk::RESPONSE_ACCEPT)
1315 needs_saving = true;
1317 else if (Signpost *o = dynamic_cast<Signpost *>(object))
1319 SignpostEditorDialog d(o, d_create_scenario_names);
1320 d.set_parent_window(*window);
1321 int response = d.run();
1322 if (response == Gtk::RESPONSE_ACCEPT)
1323 needs_saving = true;
1325 else if (Temple *o = dynamic_cast<Temple *>(object))
1327 TempleEditorDialog d(o, d_create_scenario_names);
1328 d.set_parent_window(*window);
1329 int response = d.run();
1330 if (response == Gtk::RESPONSE_ACCEPT)
1331 needs_saving = true;
1333 // we might have changed something visible
1336 else if (MapBackpack *b = dynamic_cast<MapBackpack*>(object))
1338 BackpackEditorDialog d(b);
1339 int response = d.run();
1340 if (response == Gtk::RESPONSE_ACCEPT)
1341 needs_saving = true;
1345 void MainWindow::on_smooth_map_activated()
1347 GameMap::getInstance()->applyTileStyles(0, 0, GameMap::getHeight(),
1348 GameMap::getWidth(), true);
1352 void MainWindow::on_smooth_screen_activated()
1354 bigmap->smooth_view();
1357 void MainWindow::on_edit_items_activated()
1360 d.set_parent_window(*window);
1361 int response = d.run();
1362 if (response == Gtk::RESPONSE_ACCEPT)
1363 needs_saving = true;
1366 void MainWindow::on_edit_rewards_activated()
1369 d.set_parent_window(*window);
1370 int response = d.run();
1371 if (response == Gtk::RESPONSE_ACCEPT)
1372 needs_saving = true;
1375 void MainWindow::randomize_city(City *c)
1377 std::string name = d_create_scenario_names->popRandomCityName();
1380 c->setRandomArmytypes(true, 1);
1383 void MainWindow::on_random_all_cities_activated()
1385 Citylist *cl = Citylist::getInstance();
1386 for (Citylist::iterator it = cl->begin(); it != cl->end(); it++)
1387 randomize_city(*it);
1388 needs_saving = true;
1391 void MainWindow::on_random_unnamed_cities_activated()
1393 Citylist *cl = Citylist::getInstance();
1394 for (Citylist::iterator it = cl->begin(); it != cl->end(); it++)
1396 if ((*it)->isUnnamed() == true)
1397 randomize_city(*it);
1399 needs_saving = true;
1402 void MainWindow::randomize_ruin(Ruin *r)
1404 std::string name = d_create_scenario_names->popRandomRuinName();
1408 RenamableLocation *renamable_ruin = static_cast<RenamableLocation*>(l);
1409 renamable_ruin->setName(name);
1413 void MainWindow::on_random_all_ruins_activated()
1415 Ruinlist *rl = Ruinlist::getInstance();
1416 for (Ruinlist::iterator it = rl->begin(); it != rl->end(); it++)
1417 randomize_ruin(*it);
1418 needs_saving = true;
1421 void MainWindow::on_random_unnamed_ruins_activated()
1423 Ruinlist *rl = Ruinlist::getInstance();
1424 for (Ruinlist::iterator it = rl->begin(); it != rl->end(); it++)
1426 if ((*it)->isUnnamed() == true)
1427 randomize_ruin(*it);
1429 needs_saving = true;
1432 void MainWindow::on_random_all_temples_activated()
1434 Templelist *tl = Templelist::getInstance();
1435 for (Templelist::iterator it = tl->begin(); it != tl->end(); it++)
1437 std::string name = d_create_scenario_names->popRandomTempleName();
1441 RenamableLocation *renamable_temple =
1442 static_cast<RenamableLocation*>(l);
1443 renamable_temple->setName(name);
1446 needs_saving = true;
1449 void MainWindow::on_random_unnamed_temples_activated()
1451 Templelist *tl = Templelist::getInstance();
1452 for (Templelist::iterator it = tl->begin(); it != tl->end(); it++)
1454 if ((*it)->isUnnamed() == true)
1456 std::string name = d_create_scenario_names->popRandomTempleName();
1460 RenamableLocation *renamable_temple =
1461 static_cast<RenamableLocation*>(l);
1462 renamable_temple->setName(name);
1466 needs_saving = true;
1469 void MainWindow::randomize_signpost(Signpost *signpost)
1471 std::string name = "";
1472 if ((rand() % d_create_scenario_names->getNumSignposts()) == 0)
1473 name = d_create_scenario_names->popRandomSignpost();
1475 name = d_create_scenario_names->getDynamicSignpost(signpost);
1477 name = d_create_scenario_names->popRandomSignpost();
1478 signpost->setName(name);
1481 void MainWindow::on_random_all_signs_activated()
1483 Signpostlist *sl = Signpostlist::getInstance();
1484 for (Signpostlist::iterator it = sl->begin(); it != sl->end(); it++)
1485 randomize_signpost(*it);
1486 needs_saving = true;
1489 void MainWindow::on_random_unnamed_signs_activated()
1491 Signpostlist *sl = Signpostlist::getInstance();
1492 for (Signpostlist::iterator it = sl->begin(); it != sl->end(); it++)
1494 if ((*it)->getName() == DEFAULT_SIGNPOST)
1495 randomize_signpost(*it);
1497 needs_saving = true;
1500 void MainWindow::on_help_about_activated()
1502 Gtk::AboutDialog* dialog;
1504 Glib::RefPtr<Gtk::Builder> xml
1505 = Gtk::Builder::create_from_file(get_glade_path() + "/../about-dialog.ui");
1507 xml->get_widget("dialog", dialog);
1508 dialog->set_transient_for(*window);
1509 dialog->set_icon_from_file(File::getMiscFile("various/tileset_icon.png"));
1511 dialog->set_version(PACKAGE_VERSION);
1512 dialog->set_logo(GraphicsCache::getMiscPicture("castle_icon.png")->to_pixbuf());
1520 void MainWindow::on_validate_activated()
1523 std::list<std::string> errors;
1524 std::list<std::string> warnings;
1525 game_scenario->validate(errors, warnings);
1530 if (warnings.size())
1531 s = warnings.front();
1533 s = _("No errors.");
1535 if (errors.size() > 1)
1536 s += String::ucompose(ngettext("\nThere is %1 more error", "\nThere are %1 more errors", errors.size() - 1), errors.size() - 1);
1537 if (warnings.size())
1538 s += String::ucompose(ngettext("\nThere is %1 warning", "\nThere are %1 warnings", warnings.size()), warnings.size());
1539 TimedMessageDialog dialog(*window, s, 0);
1546 void MainWindow::clear_save_file_of_scenario_specific_data()
1548 Playerlist *plist = Playerlist::getInstance();
1549 for (Playerlist::iterator i = plist->begin(); i != plist->end(); i++)
1551 (*i)->clearActionlist();
1552 (*i)->clearHistorylist();
1553 (*i)->clearStacklist();
1554 (*i)->clearFogMap();
1555 (*i)->setGold(1000);
1560 void MainWindow::on_import_map_activated()
1562 Gtk::FileChooserDialog chooser(*window, _("Choose Game to Load Map from"));
1563 Gtk::FileFilter sav_filter;
1564 sav_filter.add_pattern("*.sav");
1565 chooser.set_filter(sav_filter);
1566 chooser.set_current_folder(File::getSavePath());
1568 chooser.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1569 chooser.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
1570 chooser.set_default_response(Gtk::RESPONSE_ACCEPT);
1573 int res = chooser.run();
1575 if (res == Gtk::RESPONSE_ACCEPT)
1577 std::string filename = chooser.get_filename();
1584 delete game_scenario;
1585 game_scenario = new GameScenario(filename, broken);
1589 show_error(String::ucompose(_("Could not load game %1."),
1591 current_save_filename = "";
1595 if (d_create_scenario_names)
1596 delete d_create_scenario_names;
1597 d_create_scenario_names = new CreateScenarioRandomize();
1599 //now lets get rid of stuff.
1600 clear_save_file_of_scenario_specific_data();
1603 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
1607 void MainWindow::redraw()
1609 bigmap->draw(Playerlist::getViewingplayer());
1610 smallmap->draw(Playerlist::getActiveplayer());
1613 void MainWindow::on_switch_sets_activated()
1616 int response = d.run();
1617 if (response == Gtk::RESPONSE_ACCEPT)
1619 needs_saving = true;
1620 bigmap->screen_size_changed(bigmap_drawingarea->get_allocation());
1627 void MainWindow::on_player_toggled(PlayerItem item)
1629 Player *p = Playerlist::getInstance()->getPlayer(item.player_id);
1631 Playerlist::getInstance()->setActiveplayer(p);
1635 void MainWindow::fill_players()
1637 for (std::list<PlayerItem>::iterator it = player_buttons.begin();
1638 it != player_buttons.end(); it++)
1639 players_hbox->remove(dynamic_cast<Gtk::Widget&>(*(*it).button));
1640 player_buttons.clear();
1641 Playerlist *pl = Playerlist::getInstance();
1642 // bool sensitive = players_hbox->get_sensitive();
1643 bool sensitive = false;
1645 players_hbox->set_sensitive(true);
1646 for (Playerlist::iterator it = pl->begin(); it != pl->end(); it++)
1648 Gtk::ToggleButton *toggle = new Gtk::ToggleButton();
1649 toggle->foreach(sigc::mem_fun(toggle, &Gtk::Container::remove));
1651 Gtk::Image *image = new Gtk::Image();
1652 image->property_pixbuf() =
1653 GraphicsCache::getInstance()->getShieldPic(1, *it)->to_pixbuf();
1654 toggle->add(*manage(image));
1656 if (*it == pl->getActiveplayer())
1657 toggle->set_active(true);
1659 struct PlayerItem item;
1660 item.button = toggle;
1661 item.player_id = (*it)->getId();
1662 player_buttons.push_back(item);
1663 toggle->set_tooltip_text((*it)->getName());
1664 players_hbox->pack_start(*manage(toggle), Gtk::PACK_SHRINK);
1665 toggle->signal_toggled().connect
1666 (sigc::bind(sigc::mem_fun(this, &MainWindow::on_player_toggled), item));
1668 players_hbox->show_all();
1670 players_hbox->set_sensitive(false);