← Back to branch summary

~ubuntu-branches/ubuntu/trusty/lordsawar/trusty

« back to all changes in this revision

Viewing changes to src/gui/new-random-map-dialog.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese, Barry deFreese
  • Date: 2009-10-21 08:02:12 UTC
  • mfrom: (1.1.8 upstream) (5.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20091021080212-wpmd6xdaxrgnn63y
Tags: 0.1.6-1
[ Barry deFreese ]
* New upstream release.
  + Drop libsdl-image1.2 from build-deps, no longer needed.
* Add README.source for quilt patch system.
* Clean up debian/copyright some.
* Bump Standards Version to 3.8.3. (No changes needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/new-random-map-dialog.cpp
 
1
//  Copyright (C) 2007 Ole Laursen
 
2
//  Copyright (C) 2007, 2008, 2009 Ben Asselstine
 
3
//
 
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.
 
8
//
 
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.
 
13
//
 
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 
 
17
//  02110-1301, USA.
 
18
 
 
19
#include <config.h>
 
20
 
 
21
#include <assert.h>
 
22
#include <sigc++/functors/mem_fun.h>
 
23
#include <gtkmm.h>
 
24
 
 
25
#include "new-random-map-dialog.h"
 
26
 
 
27
#include "glade-helpers.h"
 
28
#include "defs.h"
 
29
#include "File.h"
 
30
#include "tileset.h"
 
31
#include "tilesetlist.h"
 
32
#include "armysetlist.h"
 
33
#include "citysetlist.h"
 
34
#include "shieldsetlist.h"
 
35
#include "ucompose.hpp"
 
36
#include "GameMap.h"
 
37
#include "GameScenarioOptions.h"
 
38
 
 
39
 
 
40
NewRandomMapDialog::NewRandomMapDialog()
 
41
{
 
42
    Glib::RefPtr<Gtk::Builder> xml
 
43
        = Gtk::Builder::create_from_file(get_glade_path() + 
 
44
                                         "/new-random-map-dialog.ui");
 
45
 
 
46
    xml->get_widget("dialog", dialog);
 
47
    dialog->set_icon_from_file(File::getMiscFile("various/castle_icon.png"));
 
48
    decorate(dialog);
 
49
 
 
50
    xml->get_widget("map_size_combobox", map_size_combobox);
 
51
    xml->get_widget("random_map_container", random_map_container);
 
52
    xml->get_widget("grass_scale", grass_scale);
 
53
    xml->get_widget("water_scale", water_scale);
 
54
    xml->get_widget("swamp_scale", swamp_scale);
 
55
    xml->get_widget("forest_scale", forest_scale);
 
56
    xml->get_widget("hills_scale", hills_scale);
 
57
    xml->get_widget("mountains_scale", mountains_scale);
 
58
    xml->get_widget("cities_scale", cities_scale);
 
59
    xml->get_widget("ruins_scale", ruins_scale);
 
60
    xml->get_widget("temples_scale", temples_scale);
 
61
    xml->get_widget("accept_button", accept_button);
 
62
    xml->get_widget("grass_random_togglebutton", grass_random_togglebutton);
 
63
    grass_random_togglebutton->signal_toggled().connect
 
64
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_grass_random_toggled));
 
65
    xml->get_widget("water_random_togglebutton", water_random_togglebutton);
 
66
    water_random_togglebutton->signal_toggled().connect
 
67
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_water_random_toggled));
 
68
    xml->get_widget("swamp_random_togglebutton", swamp_random_togglebutton);
 
69
    swamp_random_togglebutton->signal_toggled().connect
 
70
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_swamp_random_toggled));
 
71
    xml->get_widget("forest_random_togglebutton", forest_random_togglebutton);
 
72
    forest_random_togglebutton->signal_toggled().connect
 
73
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_forest_random_toggled));
 
74
    xml->get_widget("hills_random_togglebutton", hills_random_togglebutton);
 
75
    hills_random_togglebutton->signal_toggled().connect
 
76
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_hills_random_toggled));
 
77
    xml->get_widget("mountains_random_togglebutton", mountains_random_togglebutton);
 
78
    mountains_random_togglebutton->signal_toggled().connect
 
79
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_mountains_random_toggled));
 
80
    xml->get_widget("cities_random_togglebutton", cities_random_togglebutton);
 
81
    cities_random_togglebutton->signal_toggled().connect
 
82
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_cities_random_toggled));
 
83
 
 
84
    // fill in tile themes combobox
 
85
    
 
86
    guint32 counter = 0;
 
87
    guint32 default_id = 0;
 
88
    Gtk::Box *box;
 
89
 
 
90
    //fill in tile sizes combobox
 
91
    tile_size_combobox = manage(new Gtk::ComboBoxText);
 
92
    std::list<guint32> sizes;
 
93
    Tilesetlist::getInstance()->getSizes(sizes);
 
94
    Citysetlist::getInstance()->getSizes(sizes);
 
95
    Armysetlist::getInstance()->getSizes(sizes);
 
96
    for (std::list<guint32>::iterator it = sizes.begin(); it != sizes.end();
 
97
         it++)
 
98
      {
 
99
        Glib::ustring s = String::ucompose("%1x%1", *it);
 
100
        tile_size_combobox->append_text(s);
 
101
        if ((*it) == Tileset::getDefaultTileSize())
 
102
          default_id = counter;
 
103
        counter++;
 
104
      }
 
105
    tile_size_combobox->set_active(default_id);
 
106
    xml->get_widget("tile_size_box", box);
 
107
    box->pack_start(*tile_size_combobox, Gtk::PACK_SHRINK);
 
108
    tile_size_combobox->signal_changed().connect
 
109
      (sigc::mem_fun(*this, &NewRandomMapDialog::on_tile_size_changed));
 
110
 
 
111
    // make new tile themes combobox
 
112
    tile_theme_combobox = manage(new Gtk::ComboBoxText);
 
113
    xml->get_widget("tile_theme_box", box);
 
114
    box->pack_start(*tile_theme_combobox, Gtk::PACK_SHRINK);
 
115
 
 
116
    // make new army themes combobox
 
117
    army_theme_combobox = manage(new Gtk::ComboBoxText);
 
118
    xml->get_widget("army_theme_box", box);
 
119
    box->pack_start(*army_theme_combobox, Gtk::PACK_SHRINK);
 
120
 
 
121
    // make new city themes combobox
 
122
    city_theme_combobox = manage(new Gtk::ComboBoxText);
 
123
    xml->get_widget("city_theme_box", box);
 
124
    box->pack_start(*city_theme_combobox, Gtk::PACK_SHRINK);
 
125
 
 
126
    counter = 0;
 
127
    default_id = 0;
 
128
    shield_theme_combobox = manage(new Gtk::ComboBoxText);
 
129
    Shieldsetlist *sl = Shieldsetlist::getInstance();
 
130
    std::list<std::string> shield_themes = sl->getNames();
 
131
    for (std::list<std::string>::iterator i = shield_themes.begin(),
 
132
         end = shield_themes.end(); i != end; ++i)
 
133
      {
 
134
        if (*i == _("Default"))
 
135
          default_id = counter;
 
136
        shield_theme_combobox->append_text(Glib::filename_to_utf8(*i));
 
137
        counter++;
 
138
      }
 
139
 
 
140
    shield_theme_combobox->set_active(default_id);
 
141
 
 
142
    xml->get_widget("shield_theme_box", box);
 
143
    box->pack_start(*shield_theme_combobox, Gtk::PACK_SHRINK);
 
144
 
 
145
    on_tile_size_changed();
 
146
 
 
147
    // map size
 
148
    map_size_combobox->set_active(MAP_SIZE_NORMAL);
 
149
    map_size_combobox->signal_changed().connect(
 
150
                                                sigc::mem_fun(*this, &NewRandomMapDialog::on_map_size_changed));
 
151
    on_map_size_changed();
 
152
 
 
153
    Gtk::Label *temples_label;
 
154
    xml->get_widget("temples_label", temples_label);
 
155
    temples_label->set_sensitive(false);
 
156
    temples_scale->set_sensitive(false);
 
157
 
 
158
    Gtk::Label *ruins_label;
 
159
    xml->get_widget("ruins_label", ruins_label);
 
160
    ruins_label->set_sensitive(false);
 
161
    ruins_scale->set_sensitive(false);
 
162
 
 
163
    xml->get_widget("cities_can_produce_allies_checkbutton", 
 
164
                    cities_can_produce_allies_checkbutton);
 
165
    grass_scale->set_value(78);
 
166
    water_scale->set_value(7);
 
167
    swamp_scale->set_value(2);
 
168
    forest_scale->set_value(3);
 
169
    hills_scale->set_value(5);
 
170
    mountains_scale->set_value(5);
 
171
}
 
172
 
 
173
NewRandomMapDialog::~NewRandomMapDialog()
 
174
{
 
175
  delete dialog;
 
176
}
 
177
 
 
178
void NewRandomMapDialog::set_parent_window(Gtk::Window &parent)
 
179
{
 
180
  dialog->set_transient_for(parent);
 
181
}
 
182
 
 
183
int NewRandomMapDialog::run()
 
184
{
 
185
  dialog->show_all();
 
186
  int response = dialog->run();
 
187
  if (response == Gtk::RESPONSE_ACCEPT) // accepted
 
188
    {
 
189
      switch (map_size_combobox->get_active_row_number()) {
 
190
      case MAP_SIZE_SMALL:
 
191
        map.width = MAP_SIZE_SMALL_WIDTH;
 
192
        map.height = MAP_SIZE_SMALL_HEIGHT;
 
193
        break;
 
194
 
 
195
      case MAP_SIZE_TINY:
 
196
        map.width = MAP_SIZE_TINY_WIDTH;
 
197
        map.height = MAP_SIZE_TINY_HEIGHT;
 
198
        break;
 
199
 
 
200
      case MAP_SIZE_NORMAL:
 
201
      default:
 
202
        map.width = MAP_SIZE_NORMAL_WIDTH;
 
203
        map.height = MAP_SIZE_NORMAL_HEIGHT;
 
204
        break;
 
205
      }
 
206
 
 
207
      map.tileset = Tilesetlist::getInstance()->getTilesetDir
 
208
        (Glib::filename_from_utf8(tile_theme_combobox->get_active_text()),
 
209
         get_active_tile_size());
 
210
 
 
211
      map.shieldset = Shieldsetlist::getInstance()->getShieldsetDir
 
212
        (Glib::filename_from_utf8(shield_theme_combobox->get_active_text()));
 
213
 
 
214
      map.cityset = Citysetlist::getInstance()->getCitysetDir
 
215
        (Glib::filename_from_utf8(city_theme_combobox->get_active_text()),
 
216
         get_active_tile_size());
 
217
 
 
218
      map.armyset = Armysetlist::getInstance()->getArmysetDir
 
219
        (Glib::filename_from_utf8(army_theme_combobox->get_active_text()),
 
220
         get_active_tile_size());
 
221
 
 
222
      map.grass = int(grass_scale->get_value());
 
223
      map.water = int(water_scale->get_value());
 
224
      map.swamp = int(swamp_scale->get_value());
 
225
      map.forest = int(forest_scale->get_value());
 
226
      map.hills = int(hills_scale->get_value());
 
227
      map.mountains = int(mountains_scale->get_value());
 
228
      map.cities = int(cities_scale->get_value());
 
229
      map.ruins = int(ruins_scale->get_value());
 
230
      map.temples = int(temples_scale->get_value());
 
231
      map.signposts = 0; //auto-set in driver
 
232
    }
 
233
  return response;
 
234
}
 
235
 
 
236
void NewRandomMapDialog::on_map_size_changed()
 
237
{
 
238
  switch (map_size_combobox->get_active_row_number()) {
 
239
  case MAP_SIZE_SMALL:
 
240
    cities_scale->set_value(15);
 
241
    ruins_scale->set_value(20);
 
242
    temples_scale->set_value(4);
 
243
    break;
 
244
 
 
245
  case MAP_SIZE_TINY:
 
246
    cities_scale->set_value(10);
 
247
    ruins_scale->set_value(15);
 
248
    temples_scale->set_value(4);
 
249
    break;
 
250
 
 
251
  case MAP_SIZE_NORMAL:
 
252
  default:
 
253
    cities_scale->set_value(20);
 
254
    ruins_scale->set_value(25);
 
255
    temples_scale->set_value(4);
 
256
    break;
 
257
  }
 
258
}
 
259
 
 
260
guint32 NewRandomMapDialog::get_active_tile_size()
 
261
{
 
262
  return (guint32) atoi(tile_size_combobox->get_active_text().c_str());
 
263
}
 
264
 
 
265
void NewRandomMapDialog::on_tile_size_changed()
 
266
{
 
267
  guint32 default_id = 0;
 
268
  guint32 counter = 0;
 
269
 
 
270
  accept_button->set_sensitive(true);
 
271
  tile_theme_combobox->clear_items();
 
272
  Tilesetlist *tl = Tilesetlist::getInstance();
 
273
  std::list<std::string> tile_themes = tl->getNames(get_active_tile_size());
 
274
  for (std::list<std::string>::iterator i = tile_themes.begin(),
 
275
       end = tile_themes.end(); i != end; ++i)
 
276
    {
 
277
      if (*i == _("Default"))
 
278
        default_id = counter;
 
279
      tile_theme_combobox->append_text(Glib::filename_to_utf8(*i));
 
280
      counter++;
 
281
    }
 
282
 
 
283
  if (counter > 0)
 
284
    tile_theme_combobox->set_active(default_id);
 
285
  else
 
286
    accept_button->set_sensitive(false);
 
287
 
 
288
  army_theme_combobox->clear_items();
 
289
  Armysetlist *al = Armysetlist::getInstance();
 
290
  std::list<std::string> army_themes = al->getNames(get_active_tile_size());
 
291
  counter = 0;
 
292
  default_id = 0;
 
293
  for (std::list<std::string>::iterator i = army_themes.begin(),
 
294
       end = army_themes.end(); i != end; ++i)
 
295
    {
 
296
      if (*i == _("Default"))
 
297
        default_id = counter;
 
298
      army_theme_combobox->append_text(Glib::filename_to_utf8(*i));
 
299
      counter++;
 
300
    }
 
301
 
 
302
  if (counter > 0)
 
303
    army_theme_combobox->set_active(default_id);
 
304
  else
 
305
    accept_button->set_sensitive(false);
 
306
 
 
307
  city_theme_combobox->clear_items();
 
308
  Citysetlist *cl = Citysetlist::getInstance();
 
309
  std::list<std::string> city_themes = cl->getNames(get_active_tile_size());
 
310
  counter = 0;
 
311
  default_id = 0;
 
312
  for (std::list<std::string>::iterator i = city_themes.begin(),
 
313
       end = city_themes.end(); i != end; ++i)
 
314
    {
 
315
      if (*i == _("Default"))
 
316
        default_id = counter;
 
317
      city_theme_combobox->append_text(Glib::filename_to_utf8(*i));
 
318
      counter++;
 
319
    }
 
320
 
 
321
  if (counter > 0)
 
322
    city_theme_combobox->set_active(default_id);
 
323
  else
 
324
    accept_button->set_sensitive(false);
 
325
}
 
326
 
 
327
GameParameters NewRandomMapDialog::getParams()
 
328
{
 
329
  GameParameters g;
 
330
  GameParameters::Player p;
 
331
  p.type = GameParameters::Player::HUMAN;
 
332
  g.players.clear();
 
333
  p.name = _("The Sirians");
 
334
  p.id = 0;
 
335
  g.players.push_back(p);
 
336
  p.name = _("Elvallie");
 
337
  p.id = 1;
 
338
  g.players.push_back(p);
 
339
  p.name = _("Storm Giants");
 
340
  p.id = 2;
 
341
  g.players.push_back(p);
 
342
  p.name = _("The Selentines");
 
343
  p.id = 3;
 
344
  g.players.push_back(p);
 
345
  p.name = _("Grey Dwarves");
 
346
  p.id = 4;
 
347
  g.players.push_back(p);
 
348
  p.name = _("Horse Lords");
 
349
  p.id = 5;
 
350
  g.players.push_back(p);
 
351
  p.name = _("Orcs of Kor");
 
352
  p.id = 6;
 
353
  g.players.push_back(p);
 
354
  p.name = _("Lord Bane");
 
355
  p.id = 7;
 
356
  g.players.push_back(p);
 
357
 
 
358
  g.map_path = "";
 
359
  switch (map_size_combobox->get_active_row_number()) {
 
360
  case MAP_SIZE_SMALL:
 
361
    g.map.width = MAP_SIZE_SMALL_WIDTH;
 
362
    g.map.height = MAP_SIZE_SMALL_HEIGHT;
 
363
    g.map.ruins = int(ruins_scale->get_value());
 
364
    g.map.temples = int(temples_scale->get_value());
 
365
    break;
 
366
 
 
367
  case MAP_SIZE_TINY:
 
368
    g.map.width = MAP_SIZE_TINY_WIDTH;
 
369
    g.map.height = MAP_SIZE_TINY_HEIGHT;
 
370
    g.map.ruins = int(ruins_scale->get_value());
 
371
    g.map.temples = int(temples_scale->get_value());
 
372
    break;
 
373
 
 
374
  case MAP_SIZE_NORMAL:
 
375
  default:
 
376
    g.map.width = MAP_SIZE_NORMAL_WIDTH;
 
377
    g.map.height = MAP_SIZE_NORMAL_HEIGHT;
 
378
    g.map.ruins = int(ruins_scale->get_value());
 
379
    g.map.temples = int(temples_scale->get_value());
 
380
    break;
 
381
  }
 
382
 
 
383
  if (grass_random_togglebutton->get_active())
 
384
    g.map.grass =  
 
385
      int(grass_scale->get_adjustment()->get_lower()) + 
 
386
      (rand() % (int(grass_scale->get_adjustment()->get_upper()) -
 
387
                 int(grass_scale->get_adjustment()->get_lower()) + 1));
 
388
  else
 
389
    g.map.grass = int(grass_scale->get_value());
 
390
 
 
391
  if (water_random_togglebutton->get_active())
 
392
    g.map.water =  
 
393
      int(water_scale->get_adjustment()->get_lower()) + 
 
394
      (rand() % (int(water_scale->get_adjustment()->get_upper()) -
 
395
                 int(water_scale->get_adjustment()->get_lower()) + 1));
 
396
  else
 
397
    g.map.water = int(water_scale->get_value());
 
398
 
 
399
  if (swamp_random_togglebutton->get_active())
 
400
    g.map.swamp =  
 
401
      int(swamp_scale->get_adjustment()->get_lower()) + 
 
402
      (rand() % (int(swamp_scale->get_adjustment()->get_upper()) -
 
403
                 int(swamp_scale->get_adjustment()->get_lower()) + 1));
 
404
  else
 
405
    g.map.swamp = int(swamp_scale->get_value());
 
406
 
 
407
  if (forest_random_togglebutton->get_active())
 
408
    g.map.forest =  
 
409
      int(forest_scale->get_adjustment()->get_lower()) + 
 
410
      (rand() % (int(forest_scale->get_adjustment()->get_upper()) -
 
411
                 int(forest_scale->get_adjustment()->get_lower()) + 1));
 
412
  else
 
413
    g.map.forest = int(forest_scale->get_value());
 
414
 
 
415
  if (hills_random_togglebutton->get_active())
 
416
    g.map.hills =  
 
417
      int(hills_scale->get_adjustment()->get_lower()) + 
 
418
      (rand() % (int(hills_scale->get_adjustment()->get_upper()) -
 
419
                 int(hills_scale->get_adjustment()->get_lower()) + 1));
 
420
  else
 
421
    g.map.hills = int(hills_scale->get_value());
 
422
 
 
423
  if (mountains_random_togglebutton->get_active())
 
424
    g.map.mountains =  
 
425
      int(mountains_scale->get_adjustment()->get_lower()) + 
 
426
      (rand() % (int(mountains_scale->get_adjustment()->get_upper()) -
 
427
                 int(mountains_scale->get_adjustment()->get_lower()) 
 
428
                 + 1));
 
429
  else
 
430
    g.map.mountains = int(mountains_scale->get_value());
 
431
 
 
432
  if (cities_random_togglebutton->get_active())
 
433
    g.map.cities =  
 
434
      int(cities_scale->get_adjustment()->get_lower()) + 
 
435
      (rand() % (int(cities_scale->get_adjustment()->get_upper()) -
 
436
                 int(cities_scale->get_adjustment()->get_lower()) + 1));
 
437
  else
 
438
    g.map.cities = int(cities_scale->get_value());
 
439
 
 
440
  Tilesetlist *tl = Tilesetlist::getInstance();
 
441
  Armysetlist *al = Armysetlist::getInstance();
 
442
  Shieldsetlist *sl = Shieldsetlist::getInstance();
 
443
  Citysetlist *cl = Citysetlist::getInstance();
 
444
  g.tile_theme = tl->getTilesetDir 
 
445
    (Glib::filename_from_utf8(tile_theme_combobox->get_active_text()),
 
446
     get_active_tile_size());
 
447
 
 
448
  g.army_theme = al->getArmysetDir
 
449
    (Glib::filename_from_utf8(army_theme_combobox->get_active_text()),
 
450
     get_active_tile_size());
 
451
 
 
452
  g.shield_theme = sl->getShieldsetDir 
 
453
    (Glib::filename_from_utf8(shield_theme_combobox->get_active_text()));
 
454
 
 
455
  g.city_theme = cl->getCitysetDir 
 
456
    (Glib::filename_from_utf8(city_theme_combobox->get_active_text()),
 
457
     get_active_tile_size());
 
458
 
 
459
  g.process_armies = GameParameters::PROCESS_ARMIES_AT_PLAYERS_TURN;
 
460
 
 
461
  g.see_opponents_stacks = GameScenarioOptions::s_see_opponents_stacks;
 
462
  g.see_opponents_production = GameScenarioOptions::s_see_opponents_production;
 
463
  g.play_with_quests = GameScenarioOptions::s_play_with_quests;
 
464
  g.hidden_map = GameScenarioOptions::s_hidden_map;
 
465
  g.neutral_cities = GameScenarioOptions::s_neutral_cities;
 
466
  g.razing_cities = GameScenarioOptions::s_razing_cities;
 
467
  g.diplomacy = GameScenarioOptions::s_diplomacy;
 
468
  g.random_turns = GameScenarioOptions::s_random_turns;
 
469
  g.quick_start = Configuration::s_quick_start;
 
470
  g.intense_combat = GameScenarioOptions::s_intense_combat;
 
471
  g.military_advisor = GameScenarioOptions::s_military_advisor;
 
472
  g.cities_can_produce_allies = 
 
473
    cities_can_produce_allies_checkbutton->get_active();
 
474
 
 
475
  g.name = _("Autogenerated");
 
476
  return g;
 
477
}
 
478
 
 
479
void NewRandomMapDialog::on_grass_random_toggled()
 
480
{
 
481
  grass_scale->set_sensitive(!grass_random_togglebutton->get_active());
 
482
}
 
483
 
 
484
void NewRandomMapDialog::on_water_random_toggled()
 
485
{
 
486
  water_scale->set_sensitive(!water_random_togglebutton->get_active());
 
487
}
 
488
 
 
489
void NewRandomMapDialog::on_swamp_random_toggled()
 
490
{
 
491
  swamp_scale->set_sensitive(!swamp_random_togglebutton->get_active());
 
492
}
 
493
 
 
494
void NewRandomMapDialog::on_forest_random_toggled()
 
495
{
 
496
  forest_scale->set_sensitive(!forest_random_togglebutton->get_active());
 
497
}
 
498
 
 
499
void NewRandomMapDialog::on_hills_random_toggled()
 
500
{
 
501
  hills_scale->set_sensitive(!hills_random_togglebutton->get_active());
 
502
}
 
503
 
 
504
void NewRandomMapDialog::on_mountains_random_toggled()
 
505
{
 
506
  mountains_scale->set_sensitive(!mountains_random_togglebutton->get_active());
 
507
}
 
508
 
 
509
void NewRandomMapDialog::on_cities_random_toggled()
 
510
{
 
511
  cities_scale->set_sensitive(!cities_random_togglebutton->get_active());
 
512
}