src/gui/menu.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   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 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, see <http://www.gnu.org/licenses/>.
  16
  17 #include "gui/menu.hpp"
  18
  19 #include <math.h>
  20
  21 #include "control/joystickkeyboardcontroller.hpp"
  22 #include "gui/menu_item.hpp"
  23 #include "gui/menu_manager.hpp"
  24 #include "gui/mousecursor.hpp"
  25 #include "supertux/globals.hpp"
  26 #include "supertux/mainloop.hpp"
  27 #include "supertux/resources.hpp"
  28 #include "supertux/timer.hpp"
  29 #include "util/gettext.hpp"
  30 #include "video/drawing_context.hpp"
  31 #include "video/font.hpp"
  32
  33 static const float MENU_REPEAT_INITIAL = 0.4f;
  34 static const float MENU_REPEAT_RATE    = 0.1f;
  35
  36 extern SDL_Surface* g_screen;
  37
  38 Menu::Menu() :
  39   hit_item(),
  40   pos_x(),
  41   pos_y(),
  42   menuaction(),
  43   delete_character(),
  44   mn_input_char(),
  45   menu_repeat_time(),
  46   close(false),
  47   items(),
  48   effect_progress(),
  49   effect_start_time(),
  50   arrange_left(),
  51   active_item(),
  52   checkbox(),
  53   checkbox_checked(),
  54   back(),
  55   arrow_left(),
  56   arrow_right()
  57 {
  58   MenuManager2::all_menus.push_back(this);
  59
  60   hit_item = -1;
  61   menuaction = MENU_ACTION_NONE;
  62   delete_character = 0;
  63   mn_input_char = '\0';
  64
  65   pos_x        = SCREEN_WIDTH/2;
  66   pos_y        = SCREEN_HEIGHT/2;
  67   arrange_left = 0;
  68   active_item  = -1;
  69
  70   effect_progress   = 0.0f;
  71   effect_start_time = 0.0f;
  72
  73   checkbox.reset(new Surface("images/engine/menu/checkbox-unchecked.png"));
  74   checkbox_checked.reset(new Surface("images/engine/menu/checkbox-checked.png"));
  75   back.reset(new Surface("images/engine/menu/arrow-back.png"));
  76   arrow_left.reset(new Surface("images/engine/menu/arrow-left.png"));
  77   arrow_right.reset(new Surface("images/engine/menu/arrow-right.png"));
  78 }
  79
  80 Menu::~Menu()
  81 {
  82   MenuManager2::all_menus.remove(this);
  83
  84   for(std::vector<MenuItem*>::iterator i = items.begin();
  85       i != items.end(); ++i)
  86   {
  87     delete *i;
  88   }
  89
  90   if (MenuManager2::current_ == this)
  91     MenuManager2::current_ = NULL;
  92
  93   if (MenuManager2::previous == this)
  94     MenuManager2::previous = NULL;
  95 }
  96
  97 void
  98 Menu::set_pos(float x, float y, float rw, float rh)
  99 {
 100   pos_x = x + get_width()  * rw;
 101   pos_y = y + get_height() * rh;
 102 }
 103
 104 /* Add an item to a menu */
 105 void
 106 Menu::additem(MenuItem* item)
 107 {
 108   items.push_back(item);
 109
 110   /* If a new menu is being built, the active item shouldn't be set to
 111    * something that isn't selectable. Set the active_item to the first
 112    * selectable item added.
 113    */
 114   if (active_item == -1
 115       && item->kind != MN_HL
 116       && item->kind != MN_LABEL
 117       && item->kind != MN_INACTIVE) {
 118     active_item = items.size() - 1;
 119   }
 120 }
 121
 122 MenuItem*
 123 Menu::add_hl()
 124 {
 125   MenuItem* item = new MenuItem(MN_HL);
 126   additem(item);
 127   return item;
 128 }
 129
 130 MenuItem*
 131 Menu::add_label(const std::string& text)
 132 {
 133   MenuItem* item = new MenuItem(MN_LABEL);
 134   item->text = text;
 135   additem(item);
 136   return item;
 137 }
 138
 139 MenuItem*
 140 Menu::add_controlfield(int id, const std::string& text,
 141                        const std::string& mapping)
 142 {
 143   MenuItem* item = new MenuItem(MN_CONTROLFIELD, id);
 144   item->change_text(text);
 145   item->change_input(mapping);
 146   additem(item);
 147   return item;
 148 }
 149
 150 MenuItem*
 151 Menu::add_entry(int id, const std::string& text)
 152 {
 153   MenuItem* item = new MenuItem(MN_ACTION, id);
 154   item->text = text;
 155   additem(item);
 156   return item;
 157 }
 158
 159 MenuItem*
 160 Menu::add_inactive(int id, const std::string& text)
 161 {
 162   MenuItem* item = new MenuItem(MN_INACTIVE, id);
 163   item->text = text;
 164   additem(item);
 165   return item;
 166 }
 167
 168 MenuItem*
 169 Menu::add_toggle(int id, const std::string& text, bool toogled)
 170 {
 171   MenuItem* item = new MenuItem(MN_TOGGLE, id);
 172   item->text = text;
 173   item->toggled = toogled;
 174   additem(item);
 175   return item;
 176 }
 177
 178 MenuItem*
 179 Menu::add_string_select(int id, const std::string& text)
 180 {
 181   MenuItem* item = new MenuItem(MN_STRINGSELECT, id);
 182   item->text = text;
 183   additem(item);
 184   return item;
 185 }
 186
 187 MenuItem*
 188 Menu::add_back(const std::string& text)
 189 {
 190   MenuItem* item = new MenuItem(MN_BACK);
 191   item->text = text;
 192   additem(item);
 193   return item;
 194 }
 195
 196 MenuItem*
 197 Menu::add_submenu(const std::string& text, Menu* submenu, int id)
 198 {
 199   MenuItem* item = new MenuItem(MN_GOTO, id);
 200   item->text = text;
 201   item->target_menu = submenu;
 202   additem(item);
 203   return item;
 204 }
 205
 206 void
 207 Menu::clear()
 208 {
 209   for(std::vector<MenuItem*>::iterator i = items.begin();
 210       i != items.end(); ++i) {
 211     delete *i;
 212   }
 213   items.clear();
 214   active_item = -1;
 215 }
 216
 217 /* Process actions done on the menu */
 218 void
 219 Menu::update()
 220 {
 221   int menu_height = (int) get_height();
 222   if (menu_height > SCREEN_HEIGHT)
 223   { // Scrolling
 224     int scroll_offset = (menu_height - SCREEN_HEIGHT) / 2 + 32;
 225     pos_y = SCREEN_HEIGHT/2 - scroll_offset * ((float(active_item) / (items.size()-1)) - 0.5f) * 2.0f;
 226   }
 227
 228   effect_progress = (real_time - effect_start_time) * 6.0f;
 229
 230   if(effect_progress >= 1.0f) {
 231     effect_progress = 1.0f;
 232
 233     if (close) {
 234       MenuManager2::current_ = 0;
 235       close = false;
 236     }
 237   }
 238   else if (effect_progress <= 0.0f) {
 239     effect_progress = 0.0f;
 240   }
 241
 242   /** check main input controller... */
 243   if(g_main_controller->pressed(Controller::UP)) {
 244     menuaction = MENU_ACTION_UP;
 245     menu_repeat_time = real_time + MENU_REPEAT_INITIAL;
 246   }
 247   if(g_main_controller->hold(Controller::UP) &&
 248      menu_repeat_time != 0 && real_time > menu_repeat_time) {
 249     menuaction = MENU_ACTION_UP;
 250     menu_repeat_time = real_time + MENU_REPEAT_RATE;
 251   }
 252
 253   if(g_main_controller->pressed(Controller::DOWN)) {
 254     menuaction = MENU_ACTION_DOWN;
 255     menu_repeat_time = real_time + MENU_REPEAT_INITIAL;
 256   }
 257   if(g_main_controller->hold(Controller::DOWN) &&
 258      menu_repeat_time != 0 && real_time > menu_repeat_time) {
 259     menuaction = MENU_ACTION_DOWN;
 260     menu_repeat_time = real_time + MENU_REPEAT_RATE;
 261   }
 262
 263   if(g_main_controller->pressed(Controller::LEFT)) {
 264     menuaction = MENU_ACTION_LEFT;
 265     menu_repeat_time = real_time + MENU_REPEAT_INITIAL;
 266   }
 267   if(g_main_controller->hold(Controller::LEFT) &&
 268      menu_repeat_time != 0 && real_time > menu_repeat_time) {
 269     menuaction = MENU_ACTION_LEFT;
 270     menu_repeat_time = real_time + MENU_REPEAT_RATE;
 271   }
 272
 273   if(g_main_controller->pressed(Controller::RIGHT)) {
 274     menuaction = MENU_ACTION_RIGHT;
 275     menu_repeat_time = real_time + MENU_REPEAT_INITIAL;
 276   }
 277   if(g_main_controller->hold(Controller::RIGHT) &&
 278      menu_repeat_time != 0 && real_time > menu_repeat_time) {
 279     menuaction = MENU_ACTION_RIGHT;
 280     menu_repeat_time = real_time + MENU_REPEAT_RATE;
 281   }
 282
 283   if(g_main_controller->pressed(Controller::ACTION)
 284      || g_main_controller->pressed(Controller::MENU_SELECT)) {
 285     menuaction = MENU_ACTION_HIT;
 286   }
 287   if(g_main_controller->pressed(Controller::PAUSE_MENU)) {
 288     menuaction = MENU_ACTION_BACK;
 289   }
 290
 291   hit_item = -1;
 292   if(items.size() == 0)
 293     return;
 294
 295   int last_active_item = active_item;
 296   switch(menuaction) {
 297     case MENU_ACTION_UP:
 298       do {
 299         if (active_item > 0)
 300           --active_item;
 301         else
 302           active_item = int(items.size())-1;
 303       } while ((items[active_item]->kind == MN_HL
 304                 || items[active_item]->kind == MN_LABEL
 305                 || items[active_item]->kind == MN_INACTIVE)
 306                && (active_item != last_active_item));
 307
 308       break;
 309
 310     case MENU_ACTION_DOWN:
 311       do {
 312         if(active_item < int(items.size())-1 )
 313           ++active_item;
 314         else
 315           active_item = 0;
 316       } while ((items[active_item]->kind == MN_HL
 317                 || items[active_item]->kind == MN_LABEL
 318                 || items[active_item]->kind == MN_INACTIVE)
 319                && (active_item != last_active_item));
 320
 321       break;
 322
 323     case MENU_ACTION_LEFT:
 324       if(items[active_item]->kind == MN_STRINGSELECT) {
 325         if(items[active_item]->selected > 0)
 326           items[active_item]->selected--;
 327         else
 328           items[active_item]->selected = items[active_item]->list.size()-1;
 329
 330         menu_action(items[active_item]);
 331       }
 332       break;
 333
 334     case MENU_ACTION_RIGHT:
 335       if(items[active_item]->kind == MN_STRINGSELECT) {
 336         if(items[active_item]->selected+1 < items[active_item]->list.size())
 337           items[active_item]->selected++;
 338         else
 339           items[active_item]->selected = 0;
 340
 341         menu_action(items[active_item]);
 342       }
 343       break;
 344
 345     case MENU_ACTION_HIT: {
 346       hit_item = active_item;
 347       switch (items[active_item]->kind) {
 348         case MN_GOTO:
 349           assert(items[active_item]->target_menu != 0);
 350           MenuManager2::push_current(items[active_item]->target_menu);
 351           break;
 352
 353         case MN_TOGGLE:
 354           items[active_item]->toggled = !items[active_item]->toggled;
 355           menu_action(items[active_item]);
 356           break;
 357
 358         case MN_CONTROLFIELD:
 359           menu_action(items[active_item]);
 360           break;
 361
 362         case MN_ACTION:
 363           menu_action(items[active_item]);
 364           break;
 365
 366         case MN_STRINGSELECT:
 367           if(items[active_item]->selected+1 < items[active_item]->list.size())
 368             items[active_item]->selected++;
 369           else
 370             items[active_item]->selected = 0;
 371
 372           menu_action(items[active_item]);
 373           break;
 374
 375         case MN_TEXTFIELD:
 376         case MN_NUMFIELD:
 377           menuaction = MENU_ACTION_DOWN;
 378           update();
 379           break;
 380
 381         case MN_BACK:
 382           MenuManager2::pop_current();
 383           break;
 384         default:
 385           break;
 386       }
 387       break;
 388     }
 389
 390     case MENU_ACTION_REMOVE:
 391       if(items[active_item]->kind == MN_TEXTFIELD
 392          || items[active_item]->kind == MN_NUMFIELD)
 393       {
 394         if(!items[active_item]->input.empty())
 395         {
 396           int i = items[active_item]->input.size();
 397
 398           while(delete_character > 0)        /* remove characters */
 399           {
 400             items[active_item]->input.resize(i-1);
 401             delete_character--;
 402           }
 403         }
 404       }
 405       break;
 406
 407     case MENU_ACTION_INPUT:
 408       if(items[active_item]->kind == MN_TEXTFIELD
 409          || (items[active_item]->kind == MN_NUMFIELD
 410              && mn_input_char >= '0' && mn_input_char <= '9'))
 411       {
 412         items[active_item]->input.push_back(mn_input_char);
 413       }
 414       break;
 415
 416     case MENU_ACTION_BACK:
 417       MenuManager2::pop_current();
 418       break;
 419
 420     case MENU_ACTION_NONE:
 421       break;
 422   }
 423   menuaction = MENU_ACTION_NONE;
 424
 425   assert(active_item < int(items.size()));
 426 }
 427
 428 int
 429 Menu::check()
 430 {
 431   if (hit_item != -1) {
 432     int id = items[hit_item]->id;
 433     hit_item = -1;                      //Clear event when checked out.. (we would end up in a loop when we try to leave "fake" submenu like Addons or Contrib)
 434     return id;
 435   }
 436   else
 437     return -1;
 438 }
 439
 440 void
 441 Menu::menu_action(MenuItem* )
 442 {}
 443
 444 void
 445 Menu::draw_item(DrawingContext& context, int index)
 446 {
 447   float menu_height = get_height();
 448   float menu_width  = get_width();
 449
 450   MenuItem& pitem = *(items[index]);
 451
 452   Color text_color = default_color;
 453   float x_pos       = pos_x;
 454   float y_pos       = pos_y + 24*index - menu_height/2 + 12;
 455   int shadow_size = 2;
 456   int text_width  = int(normal_font->get_text_width(pitem.text));
 457   int input_width = int(normal_font->get_text_width(pitem.input) + 10);
 458   int list_width = 0;
 459
 460   float left  = pos_x - menu_width/2 + 16;
 461   float right = pos_x + menu_width/2 - 16;
 462
 463   if(pitem.list.size() > 0) {
 464     list_width = (int) normal_font->get_text_width(pitem.list[pitem.selected]);
 465   }
 466
 467   if (arrange_left)
 468     x_pos += 24 - menu_width/2 + (text_width + input_width + list_width)/2;
 469
 470   if(index == active_item)
 471   {
 472     shadow_size = 3;
 473     text_color = active_color;
 474   }
 475
 476   if(active_item == index)
 477   {
 478     float blink = (sinf(real_time * M_PI * 1.0f)/2.0f + 0.5f) * 0.5f + 0.25f;
 479     context.draw_filled_rect(Rect(Vector(pos_x - menu_width/2 + 10 - 2, y_pos - 12 - 2),
 480                                   Vector(pos_x + menu_width/2 - 10 + 2, y_pos + 12 + 2)),
 481                              Color(1.0f, 1.0f, 1.0f, blink),
 482                              14.0f,
 483                              LAYER_GUI-10);
 484     context.draw_filled_rect(Rect(Vector(pos_x - menu_width/2 + 10, y_pos - 12),
 485                                   Vector(pos_x + menu_width/2 - 10, y_pos + 12)),
 486                              Color(1.0f, 1.0f, 1.0f, 0.5f),
 487                              12.0f,
 488                              LAYER_GUI-10);
 489   }
 490
 491   switch (pitem.kind)
 492   {
 493     case MN_INACTIVE:
 494     {
 495       context.draw_text(normal_font, pitem.text,
 496                         Vector(pos_x, y_pos - int(normal_font->get_height()/2)),
 497                         ALIGN_CENTER, LAYER_GUI, inactive_color);
 498       break;
 499     }
 500
 501     case MN_HL:
 502     {
 503       // TODO
 504       float x = pos_x - menu_width/2;
 505       float y = y_pos - 12;
 506       /* Draw a horizontal line with a little 3d effect */
 507       context.draw_filled_rect(Vector(x, y + 6),
 508                                Vector(menu_width, 4),
 509                                Color(0.6f, 0.7f, 1.0f, 1.0f), LAYER_GUI);
 510       context.draw_filled_rect(Vector(x, y + 6),
 511                                Vector(menu_width, 2),
 512                                Color(1.0f, 1.0f, 1.0f, 1.0f), LAYER_GUI);
 513       break;
 514     }
 515     case MN_LABEL:
 516     {
 517       context.draw_text(big_font, pitem.text,
 518                         Vector(pos_x, y_pos - int(big_font->get_height()/2)),
 519                         ALIGN_CENTER, LAYER_GUI, label_color);
 520       break;
 521     }
 522     case MN_TEXTFIELD:
 523     case MN_NUMFIELD:
 524     case MN_CONTROLFIELD:
 525     {
 526       if(pitem.kind == MN_TEXTFIELD || pitem.kind == MN_NUMFIELD)
 527       {
 528         if(active_item == index)
 529           context.draw_text(normal_font,
 530                             pitem.get_input_with_symbol(true),
 531                             Vector(right, y_pos - int(normal_font->get_height()/2)),
 532                             ALIGN_RIGHT, LAYER_GUI, field_color);
 533         else
 534           context.draw_text(normal_font,
 535                             pitem.get_input_with_symbol(false),
 536                             Vector(right, y_pos - int(normal_font->get_height()/2)),
 537                             ALIGN_RIGHT, LAYER_GUI, field_color);
 538       }
 539       else
 540         context.draw_text(normal_font, pitem.input,
 541                           Vector(right, y_pos - int(normal_font->get_height()/2)),
 542                           ALIGN_RIGHT, LAYER_GUI, field_color);
 543
 544       context.draw_text(normal_font, pitem.text,
 545                         Vector(left, y_pos - int(normal_font->get_height()/2)),
 546                         ALIGN_LEFT, LAYER_GUI, text_color);
 547       break;
 548     }
 549     case MN_STRINGSELECT:
 550     {
 551       float roff = arrow_left->get_width();
 552       // Draw left side
 553       context.draw_text(normal_font, pitem.text,
 554                         Vector(left, y_pos - int(normal_font->get_height()/2)),
 555                         ALIGN_LEFT, LAYER_GUI, text_color);
 556
 557       // Draw right side
 558       context.draw_surface(arrow_left.get(),
 559                            Vector(right - list_width - roff - roff, y_pos - 8),
 560                            LAYER_GUI);
 561       context.draw_surface(arrow_right.get(),
 562                            Vector(right - roff, y_pos - 8),
 563                            LAYER_GUI);
 564       context.draw_text(normal_font, pitem.list[pitem.selected],
 565                         Vector(right - roff, y_pos - int(normal_font->get_height()/2)),
 566                         ALIGN_RIGHT, LAYER_GUI, text_color);
 567       break;
 568     }
 569     case MN_BACK:
 570     {
 571       context.draw_text(normal_font, pitem.text,
 572                         Vector(pos_x, y_pos - int(normal_font->get_height()/2)),
 573                         ALIGN_CENTER, LAYER_GUI, text_color);
 574       context.draw_surface(back.get(),
 575                            Vector(x_pos + text_width/2  + 16, y_pos - 8),
 576                            LAYER_GUI);
 577       break;
 578     }
 579
 580     case MN_TOGGLE:
 581     {
 582       context.draw_text(normal_font, pitem.text,
 583                         Vector(pos_x - menu_width/2 + 16, y_pos - (normal_font->get_height()/2)),
 584                         ALIGN_LEFT, LAYER_GUI, text_color);
 585
 586       if(pitem.toggled)
 587         context.draw_surface(checkbox_checked.get(),
 588                              Vector(x_pos + (menu_width/2-16) - checkbox->get_width(), y_pos - 8),
 589                              LAYER_GUI + 1);
 590       else
 591         context.draw_surface(checkbox.get(),
 592                              Vector(x_pos + (menu_width/2-16) - checkbox->get_width(), y_pos - 8),
 593                              LAYER_GUI + 1);
 594       break;
 595     }
 596     case MN_ACTION:
 597       context.draw_text(normal_font, pitem.text,
 598                         Vector(pos_x, y_pos - int(normal_font->get_height()/2)),
 599                         ALIGN_CENTER, LAYER_GUI, text_color);
 600       break;
 601
 602     case MN_GOTO:
 603       context.draw_text(normal_font, pitem.text,
 604                         Vector(pos_x, y_pos - int(normal_font->get_height()/2)),
 605                         ALIGN_CENTER, LAYER_GUI, text_color);
 606       break;
 607   }
 608 }
 609
 610 float
 611 Menu::get_width() const
 612 {
 613   /* The width of the menu has to be more than the width of the text
 614      with the most characters */
 615   float menu_width = 0;
 616   for(unsigned int i = 0; i < items.size(); ++i)
 617   {
 618     Font* font = normal_font;
 619     if(items[i]->kind == MN_LABEL)
 620       font = big_font;
 621
 622     float w = font->get_text_width(items[i]->text) +
 623       big_font->get_text_width(items[i]->input) + 16;
 624     if(items[i]->kind == MN_TOGGLE)
 625       w += 32;
 626
 627     if(w > menu_width)
 628       menu_width = w;
 629   }
 630
 631   return menu_width + 24;
 632 }
 633
 634 float
 635 Menu::get_height() const
 636 {
 637   return items.size() * 24;
 638 }
 639
 640 /* Draw the current menu. */
 641 void
 642 Menu::draw(DrawingContext& context)
 643 {
 644   if(MouseCursor::current()) {
 645     MouseCursor::current()->draw(context);
 646   }
 647
 648   float menu_width  = get_width();
 649   float menu_height = get_height();
 650
 651   if (effect_progress != 1.0f)
 652   {
 653     if (close)
 654     {
 655       menu_width  = (MenuManager2::current_->get_width()  * (1.0f - effect_progress));
 656       menu_height = (MenuManager2::current_->get_height() * (1.0f - effect_progress));
 657     }
 658     else if (MenuManager2::previous)
 659     {
 660       menu_width  = (menu_width  * effect_progress) + (MenuManager2::previous->get_width()  * (1.0f - effect_progress));
 661       menu_height = (menu_height * effect_progress) + (MenuManager2::previous->get_height() * (1.0f - effect_progress));
 662       //std::cout << effect_progress << " " << this << " " << last_menus.back() << std::endl;
 663     }
 664     else
 665     {
 666       menu_width  *= effect_progress;
 667       menu_height *= effect_progress;
 668     }
 669   }
 670
 671   /* Draw a transparent background */
 672   context.draw_filled_rect(Rect(Vector(pos_x - menu_width/2-4, pos_y - menu_height/2 - 10-4),
 673                                 Vector(pos_x + menu_width/2+4, pos_y - menu_height/2 + 10 + menu_height+4)),
 674                            Color(0.2f, 0.3f, 0.4f, 0.8f),
 675                            20.0f,
 676                            LAYER_GUI-10);
 677
 678   context.draw_filled_rect(Rect(Vector(pos_x - menu_width/2, pos_y - menu_height/2 - 10),
 679                                 Vector(pos_x + menu_width/2, pos_y - menu_height/2 + 10 + menu_height)),
 680                            Color(0.6f, 0.7f, 0.8f, 0.5f),
 681                            16.0f,
 682                            LAYER_GUI-10);
 683
 684   if (!items[active_item]->help.empty())
 685   {
 686     int text_width  = (int) normal_font->get_text_width(items[active_item]->help);
 687     int text_height = (int) normal_font->get_text_height(items[active_item]->help);
 688
 689     Rect text_rect(pos_x - text_width/2 - 8,
 690                    SCREEN_HEIGHT - 48 - text_height/2 - 4,
 691                    pos_x + text_width/2 + 8,
 692                    SCREEN_HEIGHT - 48 + text_height/2 + 4);
 693
 694     context.draw_filled_rect(Rect(text_rect.p1 - Vector(4,4),
 695                                   text_rect.p2 + Vector(4,4)),
 696                              Color(0.2f, 0.3f, 0.4f, 0.8f),
 697                              16.0f,
 698                              LAYER_GUI-10);
 699
 700     context.draw_filled_rect(text_rect,
 701                              Color(0.6f, 0.7f, 0.8f, 0.5f),
 702                              16.0f,
 703                              LAYER_GUI-10);
 704
 705     context.draw_text(normal_font, items[active_item]->help,
 706                       Vector(pos_x, SCREEN_HEIGHT - 48 - text_height/2),
 707                       ALIGN_CENTER, LAYER_GUI);
 708   }
 709
 710   if (effect_progress == 1.0f)
 711     for(unsigned int i = 0; i < items.size(); ++i)
 712     {
 713       draw_item(context, i);
 714     }
 715 }
 716
 717 MenuItem&
 718 Menu::get_item_by_id(int id)
 719 {
 720   for(std::vector<MenuItem*>::iterator i = items.begin();
 721       i != items.end(); ++i) {
 722     MenuItem& item = **i;
 723
 724     if(item.id == id)
 725       return item;
 726   }
 727
 728   throw std::runtime_error("MenuItem not found");
 729 }
 730
 731 const MenuItem&
 732 Menu::get_item_by_id(int id) const
 733 {
 734   for(std::vector<MenuItem*>::const_iterator i = items.begin();
 735       i != items.end(); ++i) {
 736     const MenuItem& item = **i;
 737
 738     if(item.id == id)
 739       return item;
 740   }
 741
 742   throw std::runtime_error("MenuItem not found");
 743 }
 744
 745 int Menu::get_active_item_id()
 746 {
 747   return items[active_item]->id;
 748 }
 749
 750 bool
 751 Menu::is_toggled(int id) const
 752 {
 753   return get_item_by_id(id).toggled;
 754 }
 755
 756 void
 757 Menu::set_toggled(int id, bool toggled)
 758 {
 759   get_item_by_id(id).toggled = toggled;
 760 }
 761
 762 Menu*
 763 Menu::get_parent() const
 764 {
 765   if (MenuManager2::last_menus.empty())
 766     return 0;
 767   else
 768     return MenuManager2::last_menus.back();
 769 }
 770
 771 /* Check for menu event */
 772 void
 773 Menu::event(const SDL_Event& event)
 774 {
 775   if(effect_progress != 1.0f)
 776     return;
 777
 778   switch(event.type) {
 779     case SDL_MOUSEBUTTONDOWN:
 780     {
 781       int x = int(event.motion.x * float(SCREEN_WIDTH)/g_screen->w);
 782       int y = int(event.motion.y * float(SCREEN_HEIGHT)/g_screen->h);
 783
 784       if(x > pos_x - get_width()/2 &&
 785          x < pos_x + get_width()/2 &&
 786          y > pos_y - get_height()/2 &&
 787          y < pos_y + get_height()/2)
 788       {
 789         menuaction = MENU_ACTION_HIT;
 790       }
 791     }
 792     break;
 793
 794     case SDL_MOUSEMOTION:
 795     {
 796       float x = event.motion.x * SCREEN_WIDTH/g_screen->w;
 797       float y = event.motion.y * SCREEN_HEIGHT/g_screen->h;
 798
 799       if(x > pos_x - get_width()/2 &&
 800          x < pos_x + get_width()/2 &&
 801          y > pos_y - get_height()/2 &&
 802          y < pos_y + get_height()/2)
 803       {
 804         int new_active_item
 805           = static_cast<int> ((y - (pos_y - get_height()/2)) / 24);
 806
 807         /* only change the mouse focus to a selectable item */
 808         if ((items[new_active_item]->kind != MN_HL)
 809             && (items[new_active_item]->kind != MN_LABEL)
 810             && (items[new_active_item]->kind != MN_INACTIVE))
 811           active_item = new_active_item;
 812
 813         if(MouseCursor::current())
 814           MouseCursor::current()->set_state(MC_LINK);
 815       }
 816       else
 817       {
 818         if(MouseCursor::current())
 819           MouseCursor::current()->set_state(MC_NORMAL);
 820       }
 821     }
 822     break;
 823
 824     default:
 825       break;
 826   }
 827 }
 828
 829 void
 830 Menu::set_active_item(int id)
 831 {
 832   for(size_t i = 0; i < items.size(); ++i) {
 833     MenuItem* item = items[i];
 834     if(item->id == id) {
 835       active_item = i;
 836       break;
 837     }
 838   }
 839 }
 840
 841 /* EOF */