← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gui/hero-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/hero-dialog.cpp
1
 
//  Copyright (C) 2007, Ole Laursen
2
 
//  Copyright (C) 2007, 2008 Ben Asselstine
 
1
//  Copyright (C) 2007 Ole Laursen
 
2
//  Copyright (C) 2007, 2008, 2009 Ben Asselstine
3
3
//
4
4
//  This program is free software; you can redistribute it and/or modify
5
5
//  it under the terms of the GNU General Public License as published by
6
 
//  the Free Software Foundation; either version 2 of the License, or
 
6
//  the Free Software Foundation; either version 3 of the License, or
7
7
//  (at your option) any later version.
8
8
//
9
9
//  This program is distributed in the hope that it will be useful,
20
20
 
21
21
#include <iomanip>
22
22
 
23
 
#include <libglademm/xml.h>
 
23
#include <gtkmm.h>
24
24
#include <sigc++/functors/mem_fun.h>
25
 
#include <gtkmm/image.h>
 
25
#include <vector>
26
26
 
27
27
#include "hero-dialog.h"
28
28
 
29
29
#include "glade-helpers.h"
30
30
#include "image-helpers.h"
 
31
#include "input-helpers.h"
31
32
#include "ucompose.hpp"
32
33
#include "defs.h"
33
34
#include "hero.h"
40
41
 
41
42
HeroDialog::HeroDialog(Hero *h, Vector<int> p)
42
43
{
43
 
    GraphicsCache *gc = GraphicsCache::getInstance();
 
44
  inhibit_hero_changed = false;
44
45
    hero = h;
45
46
    pos = p;
46
47
    
47
 
    Glib::RefPtr<Gnome::Glade::Xml> xml
48
 
        = Gnome::Glade::Xml::create(get_glade_path()
49
 
                                    + "/hero-dialog.glade");
50
 
 
51
 
    Gtk::Dialog *d = 0;
52
 
    xml->get_widget("dialog", d);
53
 
    dialog.reset(d);
54
 
    decorate(dialog.get());
55
 
    window_closed.connect(sigc::mem_fun(dialog.get(), &Gtk::Dialog::hide));
56
 
    set_title(hero->getName());
57
 
 
58
 
    Gtk::Label *hero_label;
59
 
    xml->get_widget("hero_label", hero_label);
60
 
    hero_label->set_markup("<b>" + hero->getName() + "</b>");
61
 
 
62
 
    Gtk::Image *hero_image;
63
 
    xml->get_widget("hero_image", hero_image);
64
 
    hero_image->property_pixbuf() = to_pixbuf(gc->getArmyPic(hero));
 
48
    Glib::RefPtr<Gtk::Builder> xml
 
49
        = Gtk::Builder::create_from_file(get_glade_path()
 
50
                                    + "/hero-dialog.ui");
 
51
 
 
52
    xml->get_widget("dialog", dialog);
 
53
    decorate(dialog);
 
54
    window_closed.connect(sigc::mem_fun(dialog, &Gtk::Dialog::hide));
 
55
    xml->get_widget("map_image", map_image);
 
56
 
 
57
    std::list<Hero*> heroes;
 
58
    heroes = Playerlist::getActiveplayer()->getHeroes();
 
59
    heroesmap = new HeroesMap(heroes);
 
60
    if (hero)
 
61
      heroesmap->setSelectedHero(hero);
 
62
    else
 
63
      {
 
64
        Player *p = Playerlist::getActiveplayer();
 
65
        hero = *heroes.begin();
 
66
        pos = p->getPositionOfArmyById(hero->getId());
 
67
        heroesmap->setSelectedHero(hero);
 
68
      }
 
69
    heroesmap->map_changed.connect(
 
70
        sigc::mem_fun(this, &HeroDialog::on_map_changed));
 
71
    Gtk::EventBox *map_eventbox;
 
72
    xml->get_widget("map_eventbox", map_eventbox);
 
73
    map_eventbox->add_events(Gdk::BUTTON_PRESS_MASK);
 
74
    map_eventbox->signal_button_press_event().connect(
 
75
        sigc::mem_fun(*this, &HeroDialog::on_map_mouse_button_event));
65
76
 
66
77
    xml->get_widget("info_label1", info_label1);
67
78
    xml->get_widget("info_label2", info_label2);
68
 
    fill_in_info_labels();
69
 
        
 
79
 
70
80
    xml->get_widget("drop_button", drop_button);
71
81
    xml->get_widget("pickup_button", pickup_button);
72
 
 
73
82
    drop_button->signal_clicked()
74
83
        .connect(sigc::mem_fun(this, &HeroDialog::on_drop_clicked));
75
84
    pickup_button->signal_clicked()
76
85
        .connect(sigc::mem_fun(this, &HeroDialog::on_pickup_clicked));
77
86
    
 
87
    xml->get_widget("next_button", next_button);
 
88
    xml->get_widget("prev_button", prev_button);
 
89
    next_button->signal_clicked()
 
90
        .connect(sigc::mem_fun(this, &HeroDialog::on_next_clicked));
 
91
    prev_button->signal_clicked()
 
92
        .connect(sigc::mem_fun(this, &HeroDialog::on_prev_clicked));
 
93
    if (heroes.size() <= 1)
 
94
      {
 
95
        next_button->set_sensitive(false);
 
96
        prev_button->set_sensitive(false);
 
97
      }
 
98
 
 
99
    heroes_list = Gtk::ListStore::create(heroes_columns);
 
100
    xml->get_widget("heroes_treeview", heroes_treeview);
 
101
    heroes_treeview->set_model(heroes_list);
 
102
    heroes_treeview->append_column(_("Hero"), heroes_columns.name);
 
103
 
 
104
    heroes_list->clear();
 
105
    guint32 count = 0;
 
106
    for (std::list<Hero*>::iterator it = heroes.begin(); it != heroes.end();
 
107
         it++)
 
108
      {
 
109
        add_hero (*it);
 
110
      if (*it == hero)
 
111
        {
 
112
          Gtk::TreeModel::Row row;
 
113
          row = heroes_treeview->get_model()->children()[count];
 
114
          heroes_treeview->get_selection()->select(row);
 
115
        }
 
116
      count++;
 
117
      }
 
118
    heroes_treeview->get_selection()->signal_changed()
 
119
        .connect(sigc::mem_fun(this, &HeroDialog::on_hero_changed));
 
120
 
78
121
    item_list = Gtk::ListStore::create(item_columns);
79
122
    xml->get_widget("treeview", item_treeview);
80
123
    item_treeview->set_model(item_list);
84
127
    item_treeview->append_column(_("Status"), item_columns.status);
85
128
 
86
129
    item_treeview->get_selection()->signal_changed()
87
 
        .connect(sigc::mem_fun(this, &HeroDialog::on_selection_changed));
 
130
        .connect(sigc::mem_fun(this, &HeroDialog::on_item_selection_changed));
88
131
 
89
132
    events_list = Gtk::ListStore::create(events_columns);
90
133
    xml->get_widget("events_treeview", events_treeview);
91
134
    events_treeview->append_column("", events_columns.desc);
92
135
    events_treeview->set_model(events_list);
93
136
    events_list->clear();
94
 
    std::list<History* > events;
95
 
    events = hero->getOwner()->getHistoryForHeroId(hero->getId());
96
 
    for (std::list<History*>::iterator i = events.begin(); i != events.end();
97
 
         i++)
98
 
      addHistoryEvent(*i);
99
 
 
100
 
    on_selection_changed();
101
 
 
102
 
    // populate the item list
103
 
    Backpack *backpack = hero->getBackpack();
104
 
    for (Backpack::iterator i = backpack->begin(); i != backpack->end(); ++i)
105
 
        add_item(*i, true);
106
 
 
107
 
    MapBackpack *ground = GameMap::getInstance()->getTile(pos)->getBackpack();
108
 
    for (MapBackpack::iterator i = ground->begin(); i != ground->end(); i++)
109
 
      add_item(*i, false);
110
 
}
111
 
 
 
137
 
 
138
    on_item_selection_changed();
 
139
}
 
140
 
 
141
HeroDialog::~HeroDialog()
 
142
{
 
143
  delete heroesmap;
 
144
  delete dialog;
 
145
}
112
146
void HeroDialog::addHistoryEvent(History *history)
113
147
{
114
148
  Glib::ustring s = "";
205
239
 
206
240
void HeroDialog::run()
207
241
{
208
 
    GameMap *gm = GameMap::getInstance();
209
 
    dialog->show();
210
 
    dialog->run();
211
 
    if (gm->getTile(pos)->getBackpack()->size() > 0 && 
212
 
        gm->getTile(pos)->getMaptileType() == Tile::WATER)
 
242
  heroesmap->resize();
 
243
  heroesmap->draw(Playerlist::getActiveplayer());
 
244
  GameMap *gm = GameMap::getInstance();
 
245
  dialog->show_all();
 
246
  show_hero();
 
247
  dialog->run();
 
248
  if (gm->getTile(pos)->getBackpack()->size() > 0 && 
 
249
      gm->getTile(pos)->getMaptileType() == Tile::WATER)
 
250
    {
 
251
      // splash, items lost forever
 
252
      while (gm->getTile(pos)->getBackpack()->size())
 
253
        {
 
254
          MapBackpack::iterator i = gm->getTile(pos)->getBackpack()->begin();
 
255
          gm->getTile(pos)->getBackpack()->removeFromBackpack(*i);
 
256
        }
 
257
    }
 
258
}
 
259
 
 
260
void HeroDialog::update_hero_list()
 
261
{
 
262
  inhibit_hero_changed = true;
 
263
    std::list<Hero*> heroes;
 
264
    heroes = Playerlist::getActiveplayer()->getHeroes();
 
265
    guint32 count = 0;
 
266
    for (std::list<Hero*>::iterator it = heroes.begin(); it != heroes.end();
 
267
         it++)
213
268
      {
214
 
        // splash, items lost forever
215
 
        while (gm->getTile(pos)->getBackpack()->size())
216
 
          {
217
 
            MapBackpack::iterator i = gm->getTile(pos)->getBackpack()->begin();
218
 
            gm->getTile(pos)->getBackpack()->removeFromBackpack(*i);
219
 
          }
 
269
      if (*it == hero)
 
270
        {
 
271
          Gtk::TreeModel::Row row;
 
272
          row = heroes_treeview->get_model()->children()[count];
 
273
          heroes_treeview->get_selection()->select(row);
 
274
        }
 
275
      count++;
220
276
      }
221
 
}
222
 
 
223
 
void HeroDialog::on_selection_changed()
 
277
  inhibit_hero_changed = false;
 
278
}
 
279
 
 
280
void HeroDialog::on_hero_changed()
 
281
{
 
282
  if (inhibit_hero_changed == true)
 
283
    return;
 
284
  Glib::RefPtr<Gtk::TreeSelection> selection = heroes_treeview->get_selection();
 
285
  Gtk::TreeModel::iterator iterrow = selection->get_selected();
 
286
 
 
287
  if (iterrow)
 
288
    {
 
289
      Gtk::TreeModel::Row row = *iterrow;
 
290
      hero = row[heroes_columns.hero];
 
291
      pos = Playerlist::getActiveplayer()->getPositionOfArmyById(hero->getId());
 
292
      heroesmap->setSelectedHero(hero);
 
293
      show_hero();
 
294
      heroesmap->draw(Playerlist::getActiveplayer());
 
295
    }
 
296
 
 
297
}
 
298
 
 
299
void HeroDialog::on_item_selection_changed()
224
300
{
225
301
    Gtk::TreeIter i = item_treeview->get_selection()->get_selected();
226
302
    if (i)
244
320
        Item *item = (*i)[item_columns.item];
245
321
        hero->getOwner()->heroDropItem (hero, item, pos);
246
322
        (*i)[item_columns.status] = _("On the ground");
247
 
        on_selection_changed();
 
323
        on_item_selection_changed();
248
324
        fill_in_info_labels();
249
325
    }
250
326
}
251
327
 
 
328
void HeroDialog::on_next_clicked()
 
329
{
 
330
  std::list<Hero*> heroes;
 
331
  heroes = Playerlist::getActiveplayer()->getHeroes();
 
332
  std::list<Hero*>::iterator next;
 
333
  next = find (heroes.begin(), heroes.end(), hero);
 
334
  if (next != heroes.end())
 
335
    {
 
336
      next++;
 
337
      if (next == heroes.end())
 
338
        next = heroes.begin();
 
339
      hero = *next;
 
340
      heroesmap->setSelectedHero(hero);
 
341
      show_hero();
 
342
      heroesmap->draw(Playerlist::getActiveplayer());
 
343
    }
 
344
  update_hero_list();
 
345
}
 
346
void HeroDialog::on_prev_clicked()
 
347
{
 
348
  std::list<Hero*> heroes;
 
349
  heroes = Playerlist::getActiveplayer()->getHeroes();
 
350
  std::list<Hero*>::reverse_iterator prev;
 
351
  prev = find (heroes.rbegin(), heroes.rend(), hero);
 
352
  if (prev != heroes.rend())
 
353
    {
 
354
      prev++;
 
355
      if (prev == heroes.rend())
 
356
        prev = heroes.rbegin();
 
357
      hero = *prev;
 
358
      heroesmap->setSelectedHero(hero);
 
359
      show_hero();
 
360
      heroesmap->draw(Playerlist::getActiveplayer());
 
361
    }
 
362
  update_hero_list();
 
363
}
252
364
void HeroDialog::on_pickup_clicked()
253
365
{
254
366
    Gtk::TreeIter i = item_treeview->get_selection()->get_selected();
259
371
          item->setPlanted(false);
260
372
        hero->getOwner()->heroPickupItem (hero, item, pos);
261
373
        (*i)[item_columns.status] = _("In backpack");
262
 
        on_selection_changed();
 
374
        on_item_selection_changed();
263
375
        fill_in_info_labels();
264
376
    }
265
377
}
266
378
 
 
379
void HeroDialog::add_hero(Hero *h)
 
380
{
 
381
    Gtk::TreeIter i = heroes_list->append();
 
382
    (*i)[heroes_columns.name] = h->getName();
 
383
    (*i)[heroes_columns.hero] = h;
 
384
}
 
385
 
267
386
void HeroDialog::add_item(Item *item, bool in_backpack)
268
387
{
269
388
    Gtk::TreeIter i = item_list->append();
281
400
 
282
401
void HeroDialog::fill_in_info_labels()
283
402
{
284
 
    Uint32 bonus = 0;
 
403
    guint32 bonus = 0;
285
404
    Glib::ustring s;
286
405
    // fill in first column
287
406
    Backpack *backpack = hero->getBackpack();
316
435
    s += String::ucompose(_("Level: %1"), hero->getLevel());
317
436
    s += "\n";
318
437
    s += String::ucompose(_("Experience: %1"),
319
 
                          std::setprecision(2), hero->getXP());
 
438
                          std::setprecision(3), hero->getXP());
320
439
    info_label1->set_text(s);
321
440
 
322
441
    // fill in second column
332
451
    s += String::ucompose(_("Upkeep: %1"), hero->getUpkeep());
333
452
    info_label2->set_text(s);
334
453
}
 
454
 
 
455
void HeroDialog::on_map_changed(Glib::RefPtr<Gdk::Pixmap> map)
 
456
{
 
457
    map_image->property_pixmap() = map;
 
458
}
 
459
 
 
460
bool HeroDialog::on_map_mouse_button_event(GdkEventButton *e)
 
461
{
 
462
    if (e->type != GDK_BUTTON_PRESS)
 
463
        return true;    // useless event
 
464
    
 
465
    heroesmap->mouse_button_event(to_input_event(e));
 
466
    
 
467
    hero = heroesmap->getSelectedHero();
 
468
    pos = Playerlist::getActiveplayer()->getPositionOfArmyById(hero->getId());
 
469
    show_hero();
 
470
    heroesmap->draw(Playerlist::getActiveplayer());
 
471
    update_hero_list();
 
472
    return true;
 
473
}
 
474
 
 
475
void HeroDialog::show_hero()
 
476
{
 
477
    set_title(hero->getName());
 
478
 
 
479
    fill_in_info_labels();
 
480
    std::list<History* > events;
 
481
    events = hero->getOwner()->getHistoryForHeroId(hero->getId());
 
482
    events_list->clear();
 
483
    for (std::list<History*>::iterator i = events.begin(); i != events.end();
 
484
         i++)
 
485
      addHistoryEvent(*i);
 
486
        
 
487
    // populate the item list
 
488
    item_list->clear();
 
489
    Backpack *backpack = hero->getBackpack();
 
490
    for (Backpack::iterator i = backpack->begin(); i != backpack->end(); ++i)
 
491
        add_item(*i, true);
 
492
 
 
493
    MapBackpack *ground = GameMap::getInstance()->getTile(pos)->getBackpack();
 
494
    for (MapBackpack::iterator i = ground->begin(); i != ground->end(); i++)
 
495
      add_item(*i, false);
 
496
 
 
497
  return;
 
498
}