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