← Back to branch summary

~ubuntu-branches/ubuntu/raring/lordsawar/raring

« back to all changes in this revision

Viewing changes to src/editor/reward-dialog.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese, Barry deFreese, Gonéri Le Bouder
  • Date: 2008-06-17 11:15:26 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080617111526-yjyvu9df50zmpdo0
Tags: 0.0.9-1
[ Barry deFreese ]
* New upstream release.
  + Fixes gcc-4.3 builds so drop ftbfs_gcc-4.3_fix.diff.
  + Add new build-dependency for libgnet-dev.
* Add simple man page for new lordsawar-tile-editor.
* Add desktop file for lordsawar-tile-editor.
* Remove French translation on install.

[ Gonéri Le Bouder ]
* bump Debian Policy to 3.8.0. No change needed.
* fix wording in the 0.0.8-3 entry of the Debian changelog

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/editor/reward-dialog.cpp
 
1
//  Copyright (C) 2008, Ben Asselstine
 
2
//
 
3
//  This program is free software; you can redistribute it and/or modify
 
4
//  it under the terms of the GNU General Public License as published by
 
5
//  the Free Software Foundation; either version 2 of the License, or
 
6
//  (at your option) any later version.
 
7
//
 
8
//  This program is distributed in the hope that it will be useful,
 
9
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
//  GNU Library General Public License for more details.
 
12
//
 
13
//  You should have received a copy of the GNU General Public License
 
14
//  along with this program; if not, write to the Free Software
 
15
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 
 
16
//  02110-1301, USA.
 
17
 
 
18
#include <config.h>
 
19
 
 
20
#include <libglademm/xml.h>
 
21
#include <sigc++/functors/mem_fun.h>
 
22
 
 
23
#include "reward-dialog.h"
 
24
 
 
25
#include "glade-helpers.h"
 
26
#include "../ucompose.hpp"
 
27
#include "../defs.h"
 
28
#include "../reward.h"
 
29
#include "../ruin.h"
 
30
#include "../Item.h"
 
31
#include "../army.h"
 
32
#include "../GameMap.h"
 
33
#include "select-item-dialog.h"
 
34
#include "select-army-dialog.h"
 
35
#include "select-hidden-ruin-dialog.h"
 
36
 
 
37
RewardDialog::RewardDialog(Player *player, bool hidden_ruins, Reward *r)
 
38
{
 
39
  d_player = player;
 
40
  d_hidden_ruins = hidden_ruins;
 
41
  hidden_ruin = NULL;
 
42
  reward = NULL;
 
43
  item = NULL;
 
44
  ally = NULL;
 
45
 
 
46
  Glib::RefPtr<Gnome::Glade::Xml> xml
 
47
    = Gnome::Glade::Xml::create(get_glade_path()
 
48
                                + "/reward-dialog.glade");
 
49
 
 
50
  Gtk::Dialog *d = 0;
 
51
  xml->get_widget("dialog", d);
 
52
  dialog.reset(d);
 
53
 
 
54
  xml->get_widget("gold_hbox", gold_hbox);
 
55
  xml->get_widget("gold_radiobutton", gold_radiobutton);
 
56
  gold_radiobutton->signal_toggled().connect
 
57
    (sigc::mem_fun(*this, &RewardDialog::on_gold_toggled));
 
58
  xml->get_widget("item_hbox", item_hbox);
 
59
  xml->get_widget("item_radiobutton", item_radiobutton);
 
60
  item_radiobutton->signal_toggled().connect
 
61
    (sigc::mem_fun(*this, &RewardDialog::on_item_toggled));
 
62
  xml->get_widget("allies_hbox", allies_hbox);
 
63
  xml->get_widget("allies_radiobutton", allies_radiobutton);
 
64
  allies_radiobutton->signal_toggled().connect
 
65
    (sigc::mem_fun(*this, &RewardDialog::on_allies_toggled));
 
66
  xml->get_widget("map_hbox", map_hbox);
 
67
  xml->get_widget("map_radiobutton", map_radiobutton);
 
68
  map_radiobutton->signal_toggled().connect
 
69
    (sigc::mem_fun(*this, &RewardDialog::on_map_toggled));
 
70
  xml->get_widget("hidden_ruin_hbox", hidden_ruin_hbox);
 
71
  xml->get_widget("hidden_ruin_radiobutton", hidden_ruin_radiobutton);
 
72
  hidden_ruin_radiobutton->signal_toggled().connect
 
73
    (sigc::mem_fun(*this, &RewardDialog::on_hidden_ruin_toggled));
 
74
  xml->get_widget("gold_spinbutton", gold_spinbutton);
 
75
  xml->get_widget("randomize_gold_button", randomize_gold_button);
 
76
  randomize_gold_button->signal_clicked().connect
 
77
    (sigc::mem_fun(*this, &RewardDialog::on_randomize_gold_clicked));
 
78
  on_gold_toggled();
 
79
  xml->get_widget("item_button", item_button);
 
80
  item_button->signal_clicked().connect
 
81
    (sigc::mem_fun(*this, &RewardDialog::on_item_clicked));
 
82
  xml->get_widget("clear_item_button", clear_item_button);
 
83
  clear_item_button->signal_clicked().connect
 
84
    (sigc::mem_fun(*this, &RewardDialog::on_clear_item_clicked));
 
85
  xml->get_widget("randomize_item_button", randomize_item_button);
 
86
  randomize_item_button->signal_clicked().connect
 
87
    (sigc::mem_fun(*this, &RewardDialog::on_randomize_item_clicked));
 
88
  set_item_name();
 
89
 
 
90
  xml->get_widget("num_allies_spinbutton", num_allies_spinbutton);
 
91
  xml->get_widget("ally_button", ally_button);
 
92
  ally_button->signal_clicked().connect
 
93
    (sigc::mem_fun(*this, &RewardDialog::on_ally_clicked));
 
94
  xml->get_widget("clear_ally_button", clear_ally_button);
 
95
  clear_ally_button->signal_clicked().connect
 
96
    (sigc::mem_fun(*this, &RewardDialog::on_clear_ally_clicked));
 
97
  xml->get_widget("randomize_allies_button", randomize_allies_button);
 
98
  randomize_allies_button->signal_clicked().connect
 
99
    (sigc::mem_fun(*this, &RewardDialog::on_randomize_allies_clicked));
 
100
  set_ally_name();
 
101
 
 
102
  xml->get_widget("map_x_spinbutton", map_x_spinbutton);
 
103
  xml->get_widget("map_y_spinbutton", map_y_spinbutton);
 
104
  xml->get_widget("map_width_spinbutton", map_width_spinbutton);
 
105
  xml->get_widget("map_height_spinbutton", map_height_spinbutton);
 
106
  xml->get_widget("randomize_map_button", randomize_map_button);
 
107
  randomize_map_button->signal_clicked().connect
 
108
    (sigc::mem_fun(*this, &RewardDialog::on_randomize_map_clicked));
 
109
  map_x_spinbutton->set_range (0, GameMap::getInstance()->getWidth() - 1);
 
110
  map_y_spinbutton->set_range (0, GameMap::getInstance()->getHeight() - 1);
 
111
  map_width_spinbutton->set_range (1, GameMap::getInstance()->getWidth());
 
112
  map_height_spinbutton->set_range (1, GameMap::getInstance()->getHeight());
 
113
 
 
114
  xml->get_widget("hidden_ruin_button", hidden_ruin_button);
 
115
  hidden_ruin_button->signal_clicked().connect
 
116
    (sigc::mem_fun(*this, &RewardDialog::on_hidden_ruin_clicked));
 
117
  xml->get_widget("clear_hidden_ruin_button", clear_hidden_ruin_button);
 
118
  clear_hidden_ruin_button->signal_clicked().connect
 
119
    (sigc::mem_fun(*this, &RewardDialog::on_clear_hidden_ruin_clicked));
 
120
  xml->get_widget("randomize_hidden_ruin_button", randomize_hidden_ruin_button);
 
121
  randomize_hidden_ruin_button->signal_clicked().connect
 
122
    (sigc::mem_fun(*this, &RewardDialog::on_randomize_hidden_ruin_clicked));
 
123
  set_hidden_ruin_name();
 
124
  hidden_ruin_radiobutton->set_sensitive(hidden_ruins);
 
125
 
 
126
  if (r)
 
127
    {
 
128
      if (r->getType() == Reward::ITEM)
 
129
        {
 
130
          reward = new Reward_Item(*static_cast<Reward_Item*>(r));
 
131
          item = static_cast<Reward_Item*>(reward)->getItem();
 
132
        }
 
133
      else if (r->getType() == Reward::ALLIES)
 
134
        {
 
135
          reward = new Reward_Allies(*static_cast<Reward_Allies*>(r));
 
136
          ally = new Army(*static_cast<Reward_Allies*>(reward)->getArmy());
 
137
        }
 
138
      else if (r->getType() == Reward::RUIN)
 
139
        {
 
140
          reward = new Reward_Ruin(*static_cast<Reward_Ruin*>(r));
 
141
          hidden_ruin = new Ruin(*static_cast<Reward_Ruin*>(reward)->getRuin());
 
142
        }
 
143
      else if (r->getType() == Reward::MAP)
 
144
        reward = new Reward_Map(*static_cast<Reward_Map*>(r));
 
145
      else if (r->getType() == Reward::GOLD)
 
146
        reward = new Reward_Gold(*static_cast<Reward_Gold*>(r));
 
147
    }
 
148
    
 
149
  if (reward)
 
150
    fill_in_reward_info();
 
151
}
 
152
 
 
153
void RewardDialog::fill_in_reward_info()
 
154
{
 
155
  if (reward->getType() == Reward::GOLD)
 
156
    {
 
157
      Reward_Gold *r = static_cast<Reward_Gold*>(reward);
 
158
      gold_spinbutton->set_value(r->getGold());
 
159
      gold_radiobutton->set_active(true);
 
160
    }
 
161
  else if (reward->getType() == Reward::ITEM)
 
162
    {
 
163
      set_item_name();
 
164
      item_radiobutton->set_active(true);
 
165
    }
 
166
  else if (reward->getType() == Reward::ALLIES)
 
167
    {
 
168
      Reward_Allies *r = static_cast<Reward_Allies*>(reward);
 
169
      num_allies_spinbutton->set_value(r->getNoOfAllies());
 
170
      set_ally_name();
 
171
      allies_radiobutton->set_active(true);
 
172
    }
 
173
  else if (reward->getType() == Reward::MAP)
 
174
    {
 
175
      Reward_Map *r = static_cast<Reward_Map*>(reward);
 
176
      map_x_spinbutton->set_value(r->getPos().x);
 
177
      map_y_spinbutton->set_value(r->getPos().y);
 
178
      map_width_spinbutton->set_value(r->getWidth());
 
179
      map_height_spinbutton->set_value(r->getHeight());
 
180
          map_radiobutton->set_active(true);
 
181
    }
 
182
  else if (reward->getType() == Reward::RUIN)
 
183
    {
 
184
      set_hidden_ruin_name();
 
185
      hidden_ruin_radiobutton->set_active(true);
 
186
    }
 
187
 
 
188
  //reward holds a reward
 
189
}
 
190
 
 
191
void RewardDialog::set_parent_window(Gtk::Window &parent)
 
192
{
 
193
  dialog->set_transient_for(parent);
 
194
  //dialog->set_position(Gtk::WIN_POS_CENTER_ON_PARENT);
 
195
}
 
196
 
 
197
void RewardDialog::run()
 
198
{
 
199
  dialog->show_all();
 
200
  int response = dialog->run();
 
201
 
 
202
  if (response == 0)            // accepted
 
203
    {
 
204
      if (gold_radiobutton->get_active() == true)
 
205
        reward = new Reward_Gold(gold_spinbutton->get_value_as_int());
 
206
      else if (item_radiobutton->get_active() == true && item)
 
207
        reward = new Reward_Item(item);
 
208
      else if (allies_radiobutton->get_active() == true && ally)
 
209
        reward = new Reward_Allies(ally, 
 
210
                                   num_allies_spinbutton->get_value_as_int());
 
211
      else if (map_radiobutton->get_active() == true)
 
212
        reward = new Reward_Map 
 
213
          (Vector<int>(map_x_spinbutton->get_value_as_int(), 
 
214
                       map_y_spinbutton->get_value_as_int()), "",
 
215
           map_height_spinbutton->get_value_as_int(),
 
216
           map_width_spinbutton->get_value_as_int());
 
217
      else if (hidden_ruin_radiobutton->get_active() == true && hidden_ruin)
 
218
        reward = new Reward_Ruin(hidden_ruin);
 
219
      else
 
220
        {
 
221
          if (reward)
 
222
            {
 
223
              delete reward;
 
224
              reward = NULL;
 
225
            }
 
226
        }
 
227
 
 
228
          
 
229
      if (reward)
 
230
        {
 
231
        reward->setName(reward->getDescription());
 
232
        }
 
233
    }
 
234
  else
 
235
    {
 
236
      if (ally)
 
237
        delete ally;
 
238
      if (item)
 
239
        delete item;
 
240
    }
 
241
}
 
242
 
 
243
 
 
244
void RewardDialog::on_gold_toggled()
 
245
{
 
246
  gold_hbox->set_sensitive(true);
 
247
  item_hbox->set_sensitive(false);
 
248
  allies_hbox->set_sensitive(false);
 
249
  map_hbox->set_sensitive(false);
 
250
  hidden_ruin_hbox->set_sensitive(false);
 
251
}
 
252
 
 
253
void RewardDialog::on_item_toggled()
 
254
{
 
255
  gold_hbox->set_sensitive(false);
 
256
  item_hbox->set_sensitive(true);
 
257
  allies_hbox->set_sensitive(false);
 
258
  map_hbox->set_sensitive(false);
 
259
  hidden_ruin_hbox->set_sensitive(false);
 
260
}
 
261
 
 
262
void RewardDialog::on_allies_toggled()
 
263
{
 
264
  gold_hbox->set_sensitive(false);
 
265
  item_hbox->set_sensitive(false);
 
266
  allies_hbox->set_sensitive(true);
 
267
  map_hbox->set_sensitive(false);
 
268
  hidden_ruin_hbox->set_sensitive(false);
 
269
}
 
270
 
 
271
void RewardDialog::on_map_toggled()
 
272
{
 
273
  gold_hbox->set_sensitive(false);
 
274
  item_hbox->set_sensitive(false);
 
275
  allies_hbox->set_sensitive(false);
 
276
  map_hbox->set_sensitive(true);
 
277
  hidden_ruin_hbox->set_sensitive(false);
 
278
}
 
279
 
 
280
void RewardDialog::on_hidden_ruin_toggled()
 
281
{
 
282
  gold_hbox->set_sensitive(false);
 
283
  item_hbox->set_sensitive(false);
 
284
  allies_hbox->set_sensitive(false);
 
285
  map_hbox->set_sensitive(false);
 
286
  hidden_ruin_hbox->set_sensitive(true);
 
287
}
 
288
 
 
289
void RewardDialog::on_randomize_gold_clicked()
 
290
{
 
291
  gold_spinbutton->set_value(Reward_Gold::getRandomGoldPieces());
 
292
}
 
293
 
 
294
void RewardDialog::on_item_clicked()
 
295
{
 
296
  SelectItemDialog d;
 
297
  d.run();
 
298
  if (d.get_selected_item())
 
299
    {
 
300
      on_clear_item_clicked();
 
301
      item = new Item(*(d.get_selected_item()));
 
302
      set_item_name();
 
303
    }
 
304
}
 
305
 
 
306
void RewardDialog::on_clear_item_clicked()
 
307
{
 
308
  if (item)
 
309
    {
 
310
      delete item;
 
311
      item = NULL;
 
312
    }
 
313
  set_item_name();
 
314
}
 
315
 
 
316
void RewardDialog::on_randomize_item_clicked()
 
317
{
 
318
  on_clear_item_clicked();
 
319
  item = Reward_Item::getRandomItem();
 
320
  set_item_name();
 
321
}
 
322
 
 
323
void RewardDialog::set_item_name()
 
324
{
 
325
  Glib::ustring name;
 
326
  if (item)
 
327
    name = item->getName();
 
328
  else
 
329
    name = _("No item");
 
330
 
 
331
  item_button->set_label(name);
 
332
}
 
333
    
 
334
void RewardDialog::on_ally_clicked()
 
335
{
 
336
  SelectArmyDialog d(d_player, false, true);
 
337
  d.run();
 
338
  if (d.get_selected_army())
 
339
    {
 
340
      on_clear_ally_clicked();
 
341
      ally = new Army(*(d.get_selected_army()));
 
342
      set_ally_name();
 
343
    }
 
344
}
 
345
 
 
346
void RewardDialog::on_clear_ally_clicked()
 
347
{
 
348
  if (ally)
 
349
    {
 
350
      delete ally;
 
351
      ally = NULL;
 
352
    }
 
353
  set_ally_name();
 
354
}
 
355
 
 
356
void RewardDialog::on_randomize_allies_clicked()
 
357
{
 
358
  const Army *a = Reward_Allies::randomArmyAlly();
 
359
  if (!a)
 
360
    return;
 
361
    
 
362
  on_clear_ally_clicked();
 
363
  ally = new Army(*a);
 
364
  num_allies_spinbutton->set_value(Reward_Allies::getRandomAmountOfAllies());
 
365
 
 
366
  set_ally_name();
 
367
}
 
368
 
 
369
void RewardDialog::set_ally_name()
 
370
{
 
371
  Glib::ustring name;
 
372
  if (ally)
 
373
    name = ally->getName();
 
374
  else
 
375
    name = _("No ally");
 
376
 
 
377
  ally_button->set_label(name);
 
378
}
 
379
 
 
380
void RewardDialog::on_randomize_map_clicked()
 
381
{
 
382
  int x, y, width, height;
 
383
  Reward_Map::getRandomMap(&x, &y, &width, &height);
 
384
  map_x_spinbutton->set_value(x);
 
385
  map_y_spinbutton->set_value(y);
 
386
  map_width_spinbutton->set_value(width);
 
387
  map_height_spinbutton->set_value(height);
 
388
}
 
389
 
 
390
void RewardDialog::on_hidden_ruin_clicked()
 
391
{
 
392
  SelectHiddenRuinDialog d;
 
393
  d.run();
 
394
  if (d.get_selected_hidden_ruin())
 
395
    {
 
396
      on_clear_hidden_ruin_clicked();
 
397
      hidden_ruin = new Ruin(*(d.get_selected_hidden_ruin()));
 
398
      set_hidden_ruin_name();
 
399
    }
 
400
}
 
401
 
 
402
void RewardDialog::on_clear_hidden_ruin_clicked()
 
403
{
 
404
  if (hidden_ruin)
 
405
    {
 
406
      delete hidden_ruin;
 
407
      hidden_ruin = NULL;
 
408
    }
 
409
  set_hidden_ruin_name();
 
410
}
 
411
 
 
412
void RewardDialog::on_randomize_hidden_ruin_clicked()
 
413
{
 
414
  Ruin *ruin = Reward_Ruin::getRandomHiddenRuin();
 
415
  if (ruin)
 
416
    {
 
417
      on_clear_hidden_ruin_clicked();
 
418
      hidden_ruin = new Ruin(*ruin);
 
419
      set_hidden_ruin_name();
 
420
    }
 
421
}
 
422
 
 
423
void RewardDialog::set_hidden_ruin_name()
 
424
{
 
425
  Glib::ustring name;
 
426
  if (hidden_ruin)
 
427
    name = hidden_ruin->getName();
 
428
  else
 
429
    name = _("No Ruin");
 
430
 
 
431
  hidden_ruin_button->set_label(name);
 
432
}