src/gui/menu.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 #include <config.h>
  20
  21 #include <sys/types.h>
  22 #include <ctype.h>
  23
  24 #include <iostream>
  25 #include <sstream>
  26 #include <cstdlib>
  27 #include <cstdio>
  28 #include <string>
  29 #include <cassert>
  30 #include <stdexcept>
  31
  32 #include "app/globals.h"
  33 #include "menu.h"
  34 #include "video/screen.h"
  35 #include "video/drawing_context.h"
  36 #include "app/setup.h"
  37 #include "app/gettext.h"
  38 #include "math/vector.h"
  39 #include "main.h"
  40 #include "control/joystickkeyboardcontroller.h"
  41
  42 static const int MENU_REPEAT_INITIAL = 400;
  43 static const int MENU_REPEAT_RATE = 200;
  44 static const int FLICK_CURSOR_TIME=500;
  45
  46 extern SDL_Surface* screen;
  47
  48 using namespace SuperTux;
  49
  50 Surface* checkbox;
  51 Surface* checkbox_checked;
  52 Surface* back;
  53 Surface* arrow_left;
  54 Surface* arrow_right;
  55
  56 std::vector<Menu*> Menu::last_menus;
  57 Menu* Menu::current_ = 0;
  58 Font* Menu::default_font;
  59 Font* Menu::active_font;
  60 Font* Menu::deactive_font;
  61 Font* Menu::label_font;
  62 Font* Menu::field_font;
  63
  64 /* just displays a Yes/No text that can be used to confirm stuff */
  65 bool confirm_dialog(Surface *background, std::string text)
  66 {
  67   //Surface* cap_screen = Surface::CaptureScreen();
  68   Menu* dialog = new Menu;
  69   dialog->add_deactive(-1, text);
  70   dialog->add_hl();
  71   dialog->add_entry(true, _("Yes"));
  72   dialog->add_entry(false, _("No"));
  73   dialog->add_hl();
  74
  75   Menu::set_current(dialog);
  76
  77   DrawingContext context;
  78
  79   while(true)
  80     {
  81       SDL_Event event;
  82
  83       if(event.type == SDL_QUIT)
  84         throw std::runtime_error("received window close event");
  85
  86       while (SDL_PollEvent(&event)) {
  87         dialog->event(event);
  88       }
  89
  90       if(background == NULL)
  91         context.draw_gradient(Color(200,240,220), Color(200,200,220), LAYER_BACKGROUND0);
  92       else
  93         context.draw_surface(background, Vector(0,0), LAYER_BACKGROUND0);
  94
  95       dialog->draw(context);
  96       dialog->action();
  97
  98       switch (dialog->check())
  99         {
 100         case true:
 101           //delete cap_screen;
 102           Menu::set_current(0);
 103           delete dialog;
 104           return true;
 105           break;
 106         case false:
 107           //delete cap_screen;
 108           Menu::set_current(0);
 109           delete dialog;
 110           return false;
 111           break;
 112         default:
 113           break;
 114         }
 115
 116       mouse_cursor->draw(context);
 117       context.do_drawing();
 118       SDL_Delay(25);
 119     }
 120
 121   return false;
 122 }
 123
 124 void
 125 Menu::push_current(Menu* pmenu)
 126 {
 127   if (current_)
 128     last_menus.push_back(current_);
 129
 130   current_ = pmenu;
 131   current_->effect.start(500);
 132 }
 133
 134 void
 135 Menu::pop_current()
 136 {
 137   if (last_menus.size() >= 1) {
 138     current_ = last_menus.back();
 139     current_->effect.start(500);
 140
 141     last_menus.pop_back();
 142   } else {
 143     current_ = 0;
 144   }
 145 }
 146
 147 void
 148 Menu::set_current(Menu* menu)
 149 {
 150   last_menus.clear();
 151
 152   if (menu)
 153     menu->effect.start(500);
 154
 155   current_ = menu;
 156   // just to be sure...
 157   main_controller->reset();
 158 }
 159
 160 MenuItem::MenuItem(MenuItemKind _kind, int _id)
 161   : kind(_kind) , id(_id)
 162 {
 163   toggled = false;
 164   selected = false;
 165   target_menu = 0;
 166   input_flickering = false;
 167   input_flickering_timer.init(true);
 168   input_flickering_timer.start(FLICK_CURSOR_TIME);
 169 }
 170
 171 void
 172 MenuItem::change_text(const  std::string& text_)
 173 {
 174   text = text_;
 175 }
 176
 177 void
 178 MenuItem::change_input(const  std::string& text_)
 179 {
 180   input = text_;
 181 }
 182
 183 std::string MenuItem::get_input_with_symbol(bool active_item)
 184 {
 185   if(!active_item)
 186     input_flickering = true;
 187   else
 188     {
 189       if(input_flickering_timer.get_left() < 0)
 190         {
 191           if(input_flickering)
 192             input_flickering = false;
 193           else
 194             input_flickering = true;
 195           input_flickering_timer.start(FLICK_CURSOR_TIME);
 196         }
 197     }
 198
 199   char str[1024];
 200   if(input_flickering)
 201     sprintf(str,"%s ",input.c_str());
 202   else
 203     sprintf(str,"%s_",input.c_str());
 204
 205   std::string string = str;
 206
 207   return string;
 208 }
 209
 210 Menu::~Menu()
 211 {
 212   for(std::vector<MenuItem*>::iterator i = items.begin();
 213       i != items.end(); ++i)
 214     delete *i;
 215 }
 216
 217 Menu::Menu()
 218 {
 219   hit_item = -1;
 220   menuaction = MENU_ACTION_NONE;
 221   delete_character = 0;
 222   mn_input_char = '\0';
 223
 224   pos_x        = SCREEN_WIDTH/2;
 225   pos_y        = SCREEN_HEIGHT/2;
 226   arrange_left = 0;
 227   active_item  = -1;
 228   effect.init(false);
 229
 230   repeat_timer.init(true);
 231 }
 232
 233 void Menu::set_pos(int x, int y, float rw, float rh)
 234 {
 235   pos_x = x + (int)((float)get_width() * rw);
 236   pos_y = y + (int)((float)get_height() * rh);
 237 }
 238
 239 /* Add an item to a menu */
 240 void
 241 Menu::additem(MenuItem* item)
 242 {
 243   items.push_back(item);
 244
 245   /* If a new menu is being built, the active item shouldn't be set to
 246    * something that isnt selectable. Set the active_item to the first
 247    * selectable item added
 248    */
 249   if (active_item == -1
 250       && item->kind != MN_HL
 251       && item->kind != MN_LABEL
 252       && item->kind != MN_DEACTIVE) {
 253     active_item = items.size() - 1;
 254   }
 255 }
 256
 257 void
 258 Menu::add_hl()
 259 {
 260   additem(new MenuItem(MN_HL));
 261 }
 262
 263 void
 264 Menu::add_label(const std::string& text)
 265 {
 266   MenuItem* item = new MenuItem(MN_LABEL);
 267   item->text = text;
 268   additem(item);
 269 }
 270
 271 void
 272 Menu::add_controlfield(int id, const std::string& text,
 273                 const std::string& mapping)
 274 {
 275   MenuItem* item = new MenuItem(MN_CONTROLFIELD, id);
 276   item->change_text(text);
 277         item->change_input(mapping);
 278   additem(item);
 279 }
 280
 281 void
 282 Menu::add_entry(int id, const std::string& text)
 283 {
 284   MenuItem* item = new MenuItem(MN_ACTION, id);
 285   item->text = text;
 286   additem(item);
 287 }
 288
 289 void
 290 Menu::add_deactive(int id, const std::string& text)
 291 {
 292   MenuItem* item = new MenuItem(MN_DEACTIVE, id);
 293   item->text = text;
 294   additem(item);
 295 }
 296
 297 void
 298 Menu::add_toggle(int id, const std::string& text, bool toogled)
 299 {
 300   MenuItem* item = new MenuItem(MN_TOGGLE, id);
 301   item->text = text;
 302   item->toggled = toogled;
 303   additem(item);
 304 }
 305
 306 void
 307 Menu::add_back(const std::string& text)
 308 {
 309   MenuItem* item = new MenuItem(MN_BACK);
 310   item->text = text;
 311   additem(item);
 312 }
 313
 314 void
 315 Menu::add_submenu(const std::string& text, Menu* submenu, int id)
 316 {
 317   MenuItem* item = new MenuItem(MN_GOTO, id);
 318   item->text = text;
 319   item->target_menu = submenu;
 320   additem(item);
 321 }
 322
 323 void
 324 Menu::clear()
 325 {
 326   for(std::vector<MenuItem*>::iterator i = items.begin();
 327       i != items.end(); ++i) {
 328     delete *i;
 329   }
 330   items.clear();
 331   active_item = -1;
 332 }
 333
 334 /* Process actions done on the menu */
 335 void
 336 Menu::action()
 337 {
 338   /** check main input controller... */
 339   if(main_controller->pressed(Controller::UP)) {
 340     menuaction = MENU_ACTION_UP;
 341     repeat_timer.start(MENU_REPEAT_INITIAL);
 342   }
 343   if(main_controller->hold(Controller::UP) && !repeat_timer.check()) {
 344     menuaction = MENU_ACTION_UP;
 345     repeat_timer.start(MENU_REPEAT_RATE);
 346   }
 347   if(main_controller->pressed(Controller::DOWN)) {
 348     menuaction = MENU_ACTION_DOWN;
 349     repeat_timer.start(MENU_REPEAT_INITIAL);
 350   }
 351   if(main_controller->hold(Controller::DOWN) && !repeat_timer.check()) {
 352     menuaction = MENU_ACTION_DOWN;
 353     repeat_timer.start(MENU_REPEAT_RATE);
 354   }
 355   if(main_controller->pressed(Controller::JUMP)
 356      || main_controller->pressed(Controller::ACTION)
 357      || main_controller->pressed(Controller::MENU_SELECT)) {
 358     menuaction = MENU_ACTION_HIT;
 359   }
 360   if(main_controller->pressed(Controller::PAUSE_MENU)) {
 361     menuaction = MENU_ACTION_BACK;
 362   }
 363
 364   hit_item = -1;
 365   if(items.size() == 0)
 366     return;
 367
 368   int last_active_item = active_item;
 369   switch(menuaction) {
 370     case MENU_ACTION_UP:
 371       do {
 372         if (active_item > 0)
 373           --active_item;
 374         else
 375           active_item = int(items.size())-1;
 376       } while ((items[active_item]->kind == MN_HL
 377                 || items[active_item]->kind == MN_LABEL
 378                 || items[active_item]->kind == MN_DEACTIVE)
 379                && (active_item != last_active_item));
 380
 381       break;
 382
 383     case MENU_ACTION_DOWN:
 384       do {
 385         if(active_item < int(items.size())-1 )
 386           ++active_item;
 387         else
 388           active_item = 0;
 389       } while ((items[active_item]->kind == MN_HL
 390                 || items[active_item]->kind == MN_LABEL
 391                 || items[active_item]->kind == MN_DEACTIVE)
 392                && (active_item != last_active_item));
 393
 394       break;
 395
 396     case MENU_ACTION_LEFT:
 397       if(items[active_item]->kind == MN_STRINGSELECT) {
 398         if(items[active_item]->selected > 0)
 399           items[active_item]->selected--;
 400         else
 401           items[active_item]->selected = items[active_item]->list.size()-1;
 402       }
 403       break;
 404
 405     case MENU_ACTION_RIGHT:
 406       if(items[active_item]->kind == MN_STRINGSELECT) {
 407         if(items[active_item]->selected+1 < items[active_item]->list.size())
 408           items[active_item]->selected++;
 409         else
 410           items[active_item]->selected = 0;
 411       }
 412       break;
 413
 414     case MENU_ACTION_HIT: {
 415       hit_item = active_item;
 416       switch (items[active_item]->kind) {
 417         case MN_GOTO:
 418           assert(items[active_item]->target_menu != 0);
 419           Menu::push_current(items[active_item]->target_menu);
 420           break;
 421
 422         case MN_TOGGLE:
 423           items[active_item]->toggled = !items[active_item]->toggled;
 424           menu_action(items[active_item]);
 425           break;
 426
 427         case MN_CONTROLFIELD:
 428           menu_action(items[active_item]);
 429           break;
 430
 431         case MN_ACTION:
 432           menu_action(items[active_item]);
 433           break;
 434
 435         case MN_TEXTFIELD:
 436         case MN_NUMFIELD:
 437           menuaction = MENU_ACTION_DOWN;
 438           action();
 439           break;
 440
 441         case MN_BACK:
 442           Menu::pop_current();
 443           break;
 444         default:
 445           break;
 446       }
 447       break;
 448     }
 449
 450     case MENU_ACTION_REMOVE:
 451       if(items[active_item]->kind == MN_TEXTFIELD
 452          || items[active_item]->kind == MN_NUMFIELD)
 453       {
 454         if(!items[active_item]->input.empty())
 455         {
 456           int i = items[active_item]->input.size();
 457
 458           while(delete_character > 0)   /* remove charactes */
 459           {
 460             items[active_item]->input.resize(i-1);
 461             delete_character--;
 462           }
 463         }
 464       }
 465       break;
 466
 467     case MENU_ACTION_INPUT:
 468       if(items[active_item]->kind == MN_TEXTFIELD
 469          || (items[active_item]->kind == MN_NUMFIELD
 470              && mn_input_char >= '0' && mn_input_char <= '9'))
 471       {
 472         items[active_item]->input.push_back(mn_input_char);
 473       }
 474       break;
 475
 476     case MENU_ACTION_BACK:
 477       Menu::pop_current();
 478       break;
 479
 480     case MENU_ACTION_NONE:
 481       break;
 482   }
 483   menuaction = MENU_ACTION_NONE;
 484
 485   assert(active_item < int(items.size()));
 486 }
 487
 488 int
 489 Menu::check()
 490 {
 491   if (hit_item != -1)
 492     return items[hit_item]->id;
 493   else
 494     return -1;
 495 }
 496
 497 void
 498 Menu::menu_action(MenuItem* )
 499 {}
 500
 501 void
 502 Menu::draw_item(DrawingContext& context, int index)
 503 {
 504   int menu_height = get_height();
 505   int menu_width = get_width();
 506
 507   MenuItem& pitem = *(items[index]);
 508
 509   int effect_offset = 0;
 510   {
 511     int effect_time = 0;
 512
 513     if(effect.check())
 514       effect_time = effect.get_left() / 4;
 515
 516     effect_offset = (index % 2) ? effect_time : -effect_time;
 517   }
 518
 519   Font* text_font = default_font;
 520   int x_pos       = pos_x;
 521   int y_pos       = pos_y + 24*index - menu_height/2 + 12 + effect_offset;
 522   int shadow_size = 2;
 523   int text_width  = int(text_font->get_text_width(pitem.text));
 524   int input_width = int(text_font->get_text_width(pitem.input) + 10);
 525   int list_width = 0;
 526   if(pitem.list.size() > 0) {
 527     list_width = (int) text_font->get_text_width(pitem.list[pitem.selected]);
 528   }
 529
 530   if (arrange_left)
 531     x_pos += 24 - menu_width/2 + (text_width + input_width + list_width)/2;
 532
 533   if(index == active_item)
 534     {
 535       shadow_size = 3;
 536       text_font = active_font;
 537     }
 538
 539   switch (pitem.kind)
 540     {
 541     case MN_DEACTIVE:
 542       {
 543         context.draw_text(deactive_font, pitem.text,
 544                           Vector(SCREEN_WIDTH/2, y_pos - int(deactive_font->get_height()/2)),
 545                           CENTER_ALLIGN, LAYER_GUI);
 546         break;
 547       }
 548
 549     case MN_HL:
 550       {
 551         // TODO
 552         int x = pos_x - menu_width/2;
 553         int y = y_pos - 12 - effect_offset;
 554         /* Draw a horizontal line with a little 3d effect */
 555         context.draw_filled_rect(Vector(x, y + 6),
 556                                  Vector(menu_width, 4), Color(150,200,255,225), LAYER_GUI);
 557         context.draw_filled_rect(Vector(x, y + 6),
 558                                  Vector(menu_width, 2), Color(255,255,255,255), LAYER_GUI);
 559         break;
 560       }
 561     case MN_LABEL:
 562       {
 563         context.draw_text(label_font, pitem.text,
 564                           Vector(SCREEN_WIDTH/2, y_pos - int(label_font->get_height()/2)),
 565                           CENTER_ALLIGN, LAYER_GUI);
 566         break;
 567       }
 568     case MN_TEXTFIELD:
 569     case MN_NUMFIELD:
 570     case MN_CONTROLFIELD:
 571       {
 572         int width = text_width + input_width + 5;
 573         int text_pos = SCREEN_WIDTH/2 - width/2;
 574         int input_pos = text_pos + text_width + 10;
 575
 576         context.draw_filled_rect(
 577           Vector(input_pos - 5, y_pos - 10),
 578           Vector(input_width + 10, 20),
 579           Color(255,255,255,255), LAYER_GUI-5);
 580         context.draw_filled_rect(
 581           Vector(input_pos - 4, y_pos - 9),
 582           Vector(input_width + 8, 18),
 583           Color(0,0,0,128), LAYER_GUI-4);
 584
 585         if(pitem.kind == MN_TEXTFIELD || pitem.kind == MN_NUMFIELD)
 586           {
 587             if(active_item == index)
 588               context.draw_text(field_font,
 589                                 pitem.get_input_with_symbol(true),
 590                                 Vector(input_pos, y_pos - int(field_font->get_height()/2)),
 591                                 LEFT_ALLIGN, LAYER_GUI);
 592             else
 593               context.draw_text(field_font,
 594                                 pitem.get_input_with_symbol(false),
 595                                 Vector(input_pos, y_pos - int(field_font->get_height()/2)),
 596                                 LEFT_ALLIGN, LAYER_GUI);
 597           }
 598         else
 599           context.draw_text(field_font, pitem.input,
 600                             Vector(input_pos, y_pos - int(field_font->get_height()/2)),
 601                             LEFT_ALLIGN, LAYER_GUI);
 602
 603         context.draw_text(text_font, pitem.text,
 604                           Vector(text_pos, y_pos - int(text_font->get_height()/2)),
 605                           LEFT_ALLIGN, LAYER_GUI);
 606         break;
 607       }
 608     case MN_STRINGSELECT:
 609       {
 610         int list_pos_2 = list_width + 16;
 611         int list_pos   = list_width/2;
 612         int text_pos   = (text_width + 16)/2;
 613
 614         /* Draw arrows */
 615         context.draw_surface(arrow_left,
 616                              Vector(x_pos - list_pos + text_pos - 17, y_pos - 8),
 617                              LAYER_GUI);
 618         context.draw_surface(arrow_right,
 619                              Vector(x_pos - list_pos + text_pos - 1 + list_pos_2, y_pos - 8),
 620                              LAYER_GUI);
 621
 622         /* Draw input background */
 623         context.draw_filled_rect(
 624           Vector(x_pos - list_pos + text_pos - 1, y_pos - 10),
 625           Vector(list_pos_2 + 2, 20),
 626           Color(255,255,255,255), LAYER_GUI - 4);
 627         context.draw_filled_rect(
 628           Vector(x_pos - list_pos + text_pos, y_pos - 9),
 629           Vector(list_pos_2, 18),
 630           Color(0,0,0,128), LAYER_GUI - 5);
 631
 632         context.draw_text(text_font, pitem.list[pitem.selected],
 633                                  Vector(SCREEN_WIDTH/2 + text_pos, y_pos - int(text_font->get_height()/2)),
 634                                  CENTER_ALLIGN, LAYER_GUI);
 635         context.draw_text(text_font, pitem.text,
 636                                  Vector(SCREEN_WIDTH/2  + list_pos_2/2, y_pos - int(text_font->get_height()/2)),
 637                                  CENTER_ALLIGN, LAYER_GUI);
 638         break;
 639       }
 640     case MN_BACK:
 641       {
 642         context.draw_text(text_font, pitem.text,
 643                           Vector(SCREEN_WIDTH/2, y_pos - int(text_font->get_height()/2)),
 644                           CENTER_ALLIGN, LAYER_GUI);
 645         context.draw_surface(back,
 646                              Vector(x_pos + text_width/2  + 16, y_pos - 8),
 647                              LAYER_GUI);
 648         break;
 649       }
 650
 651     case MN_TOGGLE:
 652       {
 653         context.draw_text(text_font, pitem.text,
 654                           Vector(SCREEN_WIDTH/2, y_pos - (text_font->get_height()/2)),
 655                           CENTER_ALLIGN, LAYER_GUI);
 656
 657         if(pitem.toggled)
 658           context.draw_surface(checkbox_checked,
 659                                Vector(x_pos + (text_width+16)/2, y_pos - 8),
 660                                LAYER_GUI + 1);
 661         else
 662           context.draw_surface(checkbox,
 663                                Vector(x_pos + (text_width+16)/2, y_pos - 8),
 664                                LAYER_GUI + 1);
 665         break;
 666       }
 667     case MN_ACTION:
 668       context.draw_text(text_font, pitem.text,
 669                         Vector(SCREEN_WIDTH/2, y_pos - int(text_font->get_height()/2)),
 670                         CENTER_ALLIGN, LAYER_GUI);
 671       break;
 672
 673     case MN_GOTO:
 674       context.draw_text(text_font, pitem.text,
 675                         Vector(SCREEN_WIDTH/2, y_pos - int(text_font->get_height()/2)),
 676                         CENTER_ALLIGN, LAYER_GUI);
 677       break;
 678     }
 679 }
 680
 681 int Menu::get_width() const
 682   {
 683     /* The width of the menu has to be more than the width of the text
 684        with the most characters */
 685     int menu_width = 0;
 686     for(unsigned int i = 0; i < items.size(); ++i)
 687       {
 688         int w = items[i]->text.size() + items[i]->input.size() + 1;
 689         if(w > menu_width)
 690           {
 691             menu_width = w;
 692             if( items[i]->kind == MN_TOGGLE)
 693               menu_width += 2;
 694           }
 695       }
 696
 697     return (menu_width * 16 + 24);
 698   }
 699
 700 int Menu::get_height() const
 701   {
 702     return items.size() * 24;
 703   }
 704
 705 /* Draw the current menu. */
 706 void
 707 Menu::draw(DrawingContext& context)
 708 {
 709   int menu_height = get_height();
 710   int menu_width = get_width();
 711
 712   /* Draw a transparent background */
 713   context.draw_filled_rect(
 714     Vector(pos_x - menu_width/2, pos_y - 24*items.size()/2 - 10),
 715     Vector(menu_width,menu_height + 20),
 716     Color(150,180,200,125), LAYER_GUI-10);
 717
 718   for(unsigned int i = 0; i < items.size(); ++i)
 719     {
 720       draw_item(context, i);
 721     }
 722 }
 723
 724 MenuItem&
 725 Menu::get_item_by_id(int id)
 726 {
 727   for(std::vector<MenuItem*>::iterator i = items.begin();
 728       i != items.end(); ++i) {
 729     MenuItem& item = **i;
 730
 731     if(item.id == id)
 732       return item;
 733   }
 734
 735   throw std::runtime_error("MenuItem not found");
 736 }
 737
 738 const MenuItem&
 739 Menu::get_item_by_id(int id) const
 740 {
 741   for(std::vector<MenuItem*>::const_iterator i = items.begin();
 742       i != items.end(); ++i) {
 743     const MenuItem& item = **i;
 744
 745     if(item.id == id)
 746       return item;
 747   }
 748
 749   throw std::runtime_error("MenuItem not found");
 750 }
 751
 752 int Menu::get_active_item_id()
 753 {
 754   return items[active_item]->id;
 755 }
 756
 757 bool
 758 Menu::is_toggled(int id) const
 759 {
 760   return get_item_by_id(id).toggled;
 761 }
 762
 763 /* Check for menu event */
 764 void
 765 Menu::event(const SDL_Event& event)
 766 {
 767   if(effect.started())
 768     return;
 769
 770   switch(event.type) {
 771     case SDL_MOUSEBUTTONDOWN:
 772       {
 773         int x = int(event.motion.x * float(SCREEN_WIDTH)/screen->w);
 774         int y = int(event.motion.y * float(SCREEN_HEIGHT)/screen->h);
 775
 776         if(x > pos_x - get_width()/2 &&
 777             x < pos_x + get_width()/2 &&
 778             y > pos_y - get_height()/2 &&
 779             y < pos_y + get_height()/2)
 780           {
 781             menuaction = MENU_ACTION_HIT;
 782           }
 783       }
 784       break;
 785
 786     case SDL_MOUSEMOTION:
 787       {
 788         int x = int(event.motion.x * float(SCREEN_WIDTH)/screen->w);
 789         int y = int(event.motion.y * float(SCREEN_HEIGHT)/screen->h);
 790
 791         if(x > pos_x - get_width()/2 &&
 792             x < pos_x + get_width()/2 &&
 793             y > pos_y - get_height()/2 &&
 794             y < pos_y + get_height()/2)
 795           {
 796             int new_active_item = (y - (pos_y - get_height()/2)) / 24;
 797
 798             /* only change the mouse focus to a selectable item */
 799             if ((items[new_active_item]->kind != MN_HL)
 800                 && (items[new_active_item]->kind != MN_LABEL)
 801                 && (items[new_active_item]->kind != MN_DEACTIVE))
 802               active_item = new_active_item;
 803
 804             if(MouseCursor::current())
 805               MouseCursor::current()->set_state(MC_LINK);
 806           }
 807         else
 808         {
 809           if(MouseCursor::current())
 810             MouseCursor::current()->set_state(MC_NORMAL);
 811         }
 812       }
 813       break;
 814
 815     default:
 816       break;
 817     }
 818 }
 819
 820 void
 821 Menu::set_active_item(int id)
 822 {
 823   for(size_t i = 0; i < items.size(); ++i) {
 824     MenuItem* item = items[i];
 825     if(item->id == id) {
 826       active_item = i;
 827       break;
 828     }
 829   }
 830 }