← Back to branch summary

~qcumber-some/widelands/spice-up-cmake

« back to all changes in this revision

Viewing changes to src/wui/building_statistics_menu.cc

  • Committer: Jens Beyer (Qcumber-some)
  • Date: 2010-05-28 14:51:37 UTC
  • mfrom: (5149.1.226 trunk)
  • Revision ID: qcumber-some@buerotiger.de-20100528145137-0pyil9qw7szyztsw
Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/wui/building_statistics_menu.cc
19
19
 
20
20
#include "building_statistics_menu.h"
21
21
 
 
22
#include <boost/bind.hpp>
 
23
 
22
24
#include "logic/building.h"
23
25
#include "graphic/graphic.h"
24
26
#include "i18n.h"
61
63
#define UPDATE_TIME 1000  //  1 second, gametime
62
64
 
63
65
 
 
66
namespace Columns {enum {Name, Size, Prod, Owned, Build};}
 
67
 
64
68
inline Interactive_Player & Building_Statistics_Menu::iplayer() const {
65
69
        return ref_cast<Interactive_Player, UI::Panel>(*get_parent());
66
70
}
67
71
 
68
 
 
69
72
Building_Statistics_Menu::Building_Statistics_Menu
70
73
        (Interactive_Player & parent, UI::UniqueWindow::Registry & registry)
71
74
:
72
75
        UI::UniqueWindow
73
 
                (&parent,
 
76
                (&parent, "building_statistics",
74
77
                 &registry,
75
78
                 WINDOW_WIDTH, WINDOW_HEIGHT,
76
79
                 _("Building Statistics")),
105
108
        m_last_building_index(0)
106
109
{
107
110
        //  building list
108
 
        m_table.add_column (32);
109
 
        m_table.add_column(174, _("Name"));
 
111
        m_table.add_column(206, _("Name"));
110
112
        m_table.add_column (50, _("Size"),     UI::Align_HCenter);
111
113
        m_table.add_column (50, _("Prod"),     UI::Align_Right);
112
114
        m_table.add_column (50, _("Owned"),    UI::Align_Right);
113
115
        m_table.add_column (50, _("Build"),    UI::Align_HCenter);
114
116
        m_table.selected.set(this, &Building_Statistics_Menu::table_changed);
 
117
        m_table.set_column_compare
 
118
                (Columns::Size,
 
119
                 boost::bind
 
120
                        (&Building_Statistics_Menu::compare_building_size, this, _1, _2));
115
121
 
116
122
        //  toggle when to run button
117
123
        m_progbar.set_total(100);
118
124
 
119
125
        m_btn[Prev_Owned] =
120
126
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
121
 
                        (this,
 
127
                        (this, "previous_owned",
122
128
                         JUMP_PREV_BUTTON_X, OWNED_Y, 24, 24,
123
129
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
124
130
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_left.png"),
128
134
 
129
135
        m_btn[Next_Owned] =
130
136
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
131
 
                        (this,
 
137
                        (this, "next_owned",
132
138
                         JUMP_NEXT_BUTTON_X, OWNED_Y, 24, 24,
133
139
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
134
140
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_right.png"),
138
144
 
139
145
        m_btn[Prev_Construction] =
140
146
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
141
 
                        (this,
 
147
                        (this, "previous_constructed",
142
148
                         JUMP_PREV_BUTTON_X, IN_BUILD_Y, 24, 24,
143
149
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
144
150
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_left.png"),
148
154
 
149
155
        m_btn[Next_Construction] =
150
156
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
151
 
                        (this,
 
157
                        (this, "next_constructed",
152
158
                         JUMP_NEXT_BUTTON_X, IN_BUILD_Y, 24, 24,
153
159
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
154
160
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_right.png"),
158
164
 
159
165
        m_btn[Prev_Unproductive] =
160
166
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
161
 
                        (this,
 
167
                        (this, "previous_unproductive",
162
168
                         JUMP_PREV_BUTTON_X, UNPRODUCTIVE_Y, 24, 24,
163
169
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
164
170
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_left.png"),
168
174
 
169
175
        m_btn[Next_Unproductive] =
170
176
                new UI::Callback_IDButton<Building_Statistics_Menu, Jump_Targets>
171
 
                        (this,
 
177
                        (this, "next_unproductive",
172
178
                         JUMP_NEXT_BUTTON_X, UNPRODUCTIVE_Y, 24, 24,
173
179
                         g_gr->get_picture(PicMod_UI, "pics/but4.png"),
174
180
                         g_gr->get_picture(PicMod_UI, "pics/scrollbar_right.png"),
202
208
                dst.drawanim
203
209
                        (FLAG_POINT - Point(TRIANGLE_WIDTH / 2, TRIANGLE_HEIGHT),
204
210
                         m_anim, 0, &player);
205
 
        dst.drawanim(FLAG_POINT, player.flag_anim(), 0, &player);
206
211
 
207
212
        // Draw all the panels etc. above the background
208
213
        UI::Window::draw(dst);
323
328
 */
324
329
void Building_Statistics_Menu::table_changed(uint32_t) {update();}
325
330
 
326
 
namespace Columns {enum {Icon, Name, Size, Prod, Owned, Build};}
 
331
/**
 
332
 * Callback to sort table based on building size.
 
333
 */
 
334
bool Building_Statistics_Menu::compare_building_size
 
335
        (uint32_t const rowa, uint32_t const rowb)
 
336
{
 
337
        const Widelands::Tribe_Descr& tribe = iplayer().player().tribe();
 
338
        Widelands::Building_Index a = Widelands::Building_Index(m_table[rowa]);
 
339
        Widelands::Building_Index b = Widelands::Building_Index(m_table[rowb]);
 
340
        const Widelands::Building_Descr * descra = tribe.get_building_descr(a);
 
341
        const Widelands::Building_Descr * descrb = tribe.get_building_descr(b);
 
342
 
 
343
        if (!descra || !descrb)
 
344
                return false; // shouldn't happen, but be defensive
 
345
 
 
346
        // mines come last
 
347
        if (descrb->get_ismine())
 
348
                return !descra->get_ismine();
 
349
        else if (descra->get_ismine())
 
350
                return false;
 
351
 
 
352
        // smallest first
 
353
        return descra->get_size() < descrb->get_size();
 
354
}
 
355
 
327
356
 
328
357
/*
329
358
 * Update table
382
411
                                ++nr_owned;
383
412
                                if (productionsite)
384
413
                                        total_prod +=
385
 
                                        ref_cast<Widelands::ProductionSite, Widelands::BaseImmovable>
386
 
                                                (*map[vec[l].pos].get_immovable())
 
414
                                                ref_cast<Widelands::ProductionSite, Widelands::BaseImmovable>
 
415
                                                        (*map[vec[l].pos].get_immovable())
387
416
                                                .get_statistics_percent();
388
417
                        }
389
418
                }
399
428
                        m_btn[Next_Construction]->set_enabled(nr_build);
400
429
                }
401
430
 
402
 
                te->set_picture(Columns::Icon, building.get_buildicon(), "X");
403
 
 
404
431
                //  add new Table Entry
405
432
                char buffer[100];
406
 
                te->set_string(Columns::Name, building.descname());
 
433
                te->set_picture
 
434
                        (Columns::Name, building.get_buildicon(), building.descname());
407
435
 
408
436
                {
409
 
                        char const * str = "";
410
437
                        char const * pic = "pics/novalue.png";
411
438
                        if (building.get_ismine()) {
412
 
                                str = "M";
413
439
                                pic = "pics/mine.png";
414
440
                        } else switch (building.get_size()) {
415
441
                        case Widelands::BaseImmovable::SMALL:
416
 
                                str = "1";
417
442
                                pic = "pics/small.png";
418
443
                                break;
419
444
                        case Widelands::BaseImmovable::MEDIUM:
420
 
                                str = "2";
421
445
                                pic = "pics/medium.png";
422
446
                                break;
423
447
                        case Widelands::BaseImmovable::BIG:
424
 
                                str = "3";
425
448
                                pic = "pics/big.png";
426
449
                                break;
427
450
                        default:
428
451
                                assert(false);
429
452
                        }
430
 
                        te->set_picture
431
 
                                (Columns::Size, g_gr->get_picture(PicMod_UI, pic), str);
 
453
                        te->set_picture(Columns::Size, g_gr->get_picture(PicMod_UI, pic));
432
454
                }
433
455
 
434
456
                if (productionsite and nr_owned) {
435
 
                        const uint32_t percent = static_cast<uint32_t>
436
 
                                (static_cast<float>(total_prod) / static_cast<float>(nr_owned));
437
 
                        snprintf(buffer, sizeof(buffer), "%i", percent);
 
457
                        uint32_t const percent =
 
458
                                static_cast<uint32_t>
 
459
                                        (static_cast<float>(total_prod) / static_cast<float>(nr_owned));
 
460
                        snprintf(buffer, sizeof(buffer), "%3u", percent);
438
461
                        if (is_selected)  {
439
462
                                m_progbar.set_state(percent);
440
463
                                m_btn[Prev_Unproductive]->set_enabled(true);
441
464
                                m_btn[Next_Unproductive]->set_enabled(true);
442
465
                        }
443
466
                } else {
444
 
                        snprintf(buffer, sizeof(buffer), "-");
 
467
                        snprintf(buffer, sizeof(buffer), " ");
445
468
                        if (is_selected) {
446
469
                                m_btn[Prev_Unproductive]->set_enabled(false);
447
470
                                m_btn[Next_Unproductive]->set_enabled(false);
450
473
                te->set_string(Columns::Prod, buffer);
451
474
 
452
475
                //  number of this buildings
453
 
                snprintf(buffer, sizeof(buffer), "%3i", nr_owned); // space-pad for sort
 
476
                snprintf(buffer, sizeof(buffer), "%3u", nr_owned); //  space-pad for sort
454
477
                te->set_string(Columns::Owned, buffer);
455
478
                if (is_selected)
456
479
                        m_owned.set_text(buffer);
457
480
 
458
481
                //  number of currently builds
459
 
                snprintf(buffer, sizeof(buffer), "%3i", nr_build); // space-pad for sort
 
482
                snprintf(buffer, sizeof(buffer), "%3u", nr_build); //  space-pad for sort
460
483
                te->set_string(Columns::Build, buffer);
461
484
                if (is_selected)
462
485
                        m_in_build.set_text(buffer);