src/control/joystickkeyboardcontroller.cpp

   1 //  $Id$
   2 //
   3 //  SuperTux
   4 //  Copyright (C) 2006 Matthias Braun <matze@braunis.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
  20 #include <config.h>
  21
  22 #include <sstream>
  23 #include "joystickkeyboardcontroller.hpp"
  24 #include "log.hpp"
  25 #include "gui/menu.hpp"
  26 #include "gettext.hpp"
  27 #include "lisp/lisp.hpp"
  28 #include "lisp/list_iterator.hpp"
  29 #include "game_session.hpp"
  30 #include "console.hpp"
  31
  32 class JoystickKeyboardController::JoystickMenu : public Menu
  33 {
  34 public:
  35   JoystickMenu(JoystickKeyboardController* controller);
  36   virtual ~JoystickMenu();
  37
  38   void update();
  39   std::string get_button_name(int button);
  40   virtual void menu_action(MenuItem* item);
  41   JoystickKeyboardController* controller;
  42 };
  43
  44 class JoystickKeyboardController::KeyboardMenu : public Menu
  45 {
  46 public:
  47   KeyboardMenu(JoystickKeyboardController* controller);
  48   ~KeyboardMenu();
  49
  50   void update();
  51   std::string get_key_name(SDLKey key);
  52   virtual void menu_action(MenuItem* item);
  53   JoystickKeyboardController* controller;
  54 };
  55
  56 JoystickKeyboardController::JoystickKeyboardController()
  57   : wait_for_key(-1), wait_for_joybutton(-1), key_options_menu(0),
  58     joystick_options_menu(0)
  59 {
  60   // initialize default keyboard map
  61   keymap.insert(std::make_pair(SDLK_LEFT, LEFT));
  62   keymap.insert(std::make_pair(SDLK_RIGHT, RIGHT));
  63   keymap.insert(std::make_pair(SDLK_UP, UP));
  64   keymap.insert(std::make_pair(SDLK_DOWN, DOWN));
  65   keymap.insert(std::make_pair(SDLK_SPACE, JUMP));
  66   keymap.insert(std::make_pair(SDLK_LCTRL, ACTION));
  67   keymap.insert(std::make_pair(SDLK_LALT, ACTION));
  68   keymap.insert(std::make_pair(SDLK_ESCAPE, PAUSE_MENU));
  69   keymap.insert(std::make_pair(SDLK_p, PAUSE_MENU));
  70   keymap.insert(std::make_pair(SDLK_PAUSE, PAUSE_MENU));
  71   keymap.insert(std::make_pair(SDLK_RETURN, MENU_SELECT));
  72   keymap.insert(std::make_pair(SDLK_KP_ENTER, MENU_SELECT));
  73   keymap.insert(std::make_pair(SDLK_CARET, CONSOLE));
  74   keymap.insert(std::make_pair(SDLK_DELETE, PEEK_LEFT));
  75   keymap.insert(std::make_pair(SDLK_END, PEEK_RIGHT));
  76
  77   int joystick_count = SDL_NumJoysticks();
  78   min_joybuttons = -1;
  79   max_joybuttons = -1;
  80   for(int i = 0; i < joystick_count; ++i) {
  81     SDL_Joystick* joystick = SDL_JoystickOpen(i);
  82     bool good = true;
  83     if(SDL_JoystickNumButtons(joystick) < 2) {
  84       log_warning << "Joystick " << i << " has less than 2 buttons" << std::endl;
  85       good = false;
  86     }
  87     if(SDL_JoystickNumAxes(joystick) < 2
  88        && SDL_JoystickNumHats(joystick) == 0) {
  89       log_warning << "Joystick " << i << " has less than 2 axes and no hat" << std::endl;
  90       good = false;
  91     }
  92     if(!good) {
  93       SDL_JoystickClose(joystick);
  94       continue;
  95     }
  96
  97     if(min_joybuttons < 0 || SDL_JoystickNumButtons(joystick) < min_joybuttons)
  98       min_joybuttons = SDL_JoystickNumButtons(joystick);
  99     if(SDL_JoystickNumButtons(joystick) > max_joybuttons) {
 100       max_joybuttons = SDL_JoystickNumButtons(joystick);
 101     }
 102
 103     joysticks.push_back(joystick);
 104   }
 105
 106   use_hat = true;
 107   joyaxis_x = 0;
 108   joyaxis_y = 1;
 109   dead_zone_x = 1000;
 110   dead_zone_y = 1000;
 111
 112   joy_button_map.insert(std::make_pair(0, JUMP));
 113   joy_button_map.insert(std::make_pair(1, ACTION));
 114   // 6 or more Buttons
 115   if( min_joybuttons > 5 ){
 116     joy_button_map.insert(std::make_pair( 4, PEEK_LEFT));
 117     joy_button_map.insert(std::make_pair( 5, PEEK_RIGHT));
 118     // 8 or more
 119     if(min_joybuttons > 7)
 120       joy_button_map.insert(std::make_pair(min_joybuttons-1, PAUSE_MENU));
 121     // map all remaining joystick buttons to MENU_SELECT
 122     for(int i = 2; i < max_joybuttons; ++i) {
 123       if( i != min_joybuttons-1 && i !=4  && i!= 5 )
 124         joy_button_map.insert(std::make_pair(i, MENU_SELECT));
 125     }
 126
 127   } else {
 128     // map the last 2 buttons to menu and pause
 129     if(min_joybuttons > 2)
 130       joy_button_map.insert(std::make_pair(min_joybuttons-1, PAUSE_MENU));
 131     // map all remaining joystick buttons to MENU_SELECT
 132     for(int i = 2; i < max_joybuttons; ++i) {
 133       if(i != min_joybuttons-1)
 134         joy_button_map.insert(std::make_pair(i, MENU_SELECT));
 135     }
 136   }
 137
 138   // some joysticks or SDL seem to produce some bogus events after being opened
 139   Uint32 ticks = SDL_GetTicks();
 140   while(SDL_GetTicks() - ticks < 200) {
 141     SDL_Event event;
 142     SDL_PollEvent(&event);
 143   }
 144 }
 145
 146 JoystickKeyboardController::~JoystickKeyboardController()
 147 {
 148   for(std::vector<SDL_Joystick*>::iterator i = joysticks.begin();
 149       i != joysticks.end(); ++i) {
 150     if(*i != 0)
 151       SDL_JoystickClose(*i);
 152   }
 153
 154   delete key_options_menu;
 155   delete joystick_options_menu;
 156 }
 157
 158 void
 159 JoystickKeyboardController::read(const lisp::Lisp& lisp)
 160 {
 161   const lisp::Lisp* keymap_lisp = lisp.get_lisp("keymap");
 162   if(keymap_lisp) {
 163     keymap.clear();
 164     lisp::ListIterator iter(keymap_lisp);
 165     while(iter.next()) {
 166       if(iter.item() == "map") {
 167         int key = -1;
 168         std::string control;
 169         const lisp::Lisp* map = iter.lisp();
 170         map->get("key", key);
 171         map->get("control", control);
 172         if(key < SDLK_FIRST || key >= SDLK_LAST) {
 173           log_warning << "Invalid key '" << key << "' in keymap" << std::endl;
 174           continue;
 175         }
 176
 177         int i = 0;
 178         for(i = 0; controlNames[i] != 0; ++i) {
 179           if(control == controlNames[i])
 180             break;
 181         }
 182         if(controlNames[i] == 0) {
 183           log_warning << "Invalid control '" << control << "' in keymap" << std::endl;
 184           continue;
 185         }
 186         keymap.insert(std::make_pair((SDLKey) key, (Control) i));
 187       } else {
 188         log_warning << "Invalid lisp element '" << iter.item() << "' in keymap" << std::endl;
 189       }
 190     }
 191   }
 192
 193   const lisp::Lisp* joystick_lisp = lisp.get_lisp("joystick");
 194   if(joystick_lisp) {
 195     joystick_lisp->get("use_hat", use_hat);
 196     joystick_lisp->get("axis_x", joyaxis_x);
 197     joystick_lisp->get("axis_y", joyaxis_y);
 198     joystick_lisp->get("dead_zone_x", dead_zone_x);
 199     joystick_lisp->get("dead_zone_y", dead_zone_y);
 200     lisp::ListIterator iter(joystick_lisp);
 201     while(iter.next()) {
 202       if(iter.item() == "map") {
 203         int button = -1;
 204         std::string control;
 205         const lisp::Lisp* map = iter.lisp();
 206         map->get("button", button);
 207         map->get("control", control);
 208         if(button < 0 || button >= max_joybuttons) {
 209           log_warning << "Invalid button '" << button << "' in buttonmap" << std::endl;
 210           continue;
 211         }
 212
 213         int i = 0;
 214         for(i = 0; controlNames[i] != 0; ++i) {
 215           if(control == controlNames[i])
 216             break;
 217         }
 218         if(controlNames[i] == 0) {
 219           log_warning << "Invalid control '" << control << "' in buttonmap" << std::endl;
 220           continue;
 221         }
 222         reset_joybutton(button, (Control) i);
 223       }
 224     }
 225   }
 226 }
 227
 228 void
 229 JoystickKeyboardController::write(lisp::Writer& writer)
 230 {
 231   writer.start_list("keymap");
 232   for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
 233     writer.start_list("map");
 234     writer.write_int("key", (int) i->first);
 235     writer.write_string("control", controlNames[i->second]);
 236     writer.end_list("map");
 237   }
 238   writer.end_list("keymap");
 239   writer.start_list("joystick");
 240   writer.write_bool("use_hat", use_hat);
 241   writer.write_int("axis_x", joyaxis_x);
 242   writer.write_int("axis_y", joyaxis_y);
 243   writer.write_int("dead_zone_x", dead_zone_x);
 244   writer.write_int("dead_zone_y", dead_zone_y);
 245   for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end();
 246       ++i) {
 247     writer.start_list("map");
 248     writer.write_int("button", i->first);
 249     writer.write_string("control", controlNames[i->second]);
 250     writer.end_list("map");
 251   }
 252   writer.end_list("joystick");
 253 }
 254
 255 void
 256 JoystickKeyboardController::reset()
 257 {
 258   Controller::reset();
 259 }
 260
 261 void
 262 JoystickKeyboardController::process_event(const SDL_Event& event)
 263 {
 264   switch(event.type) {
 265     case SDL_KEYUP:
 266     case SDL_KEYDOWN:
 267       process_key_event(event);
 268       break;
 269
 270     case SDL_JOYAXISMOTION:
 271       if(event.jaxis.axis == joyaxis_x) {
 272         if(event.jaxis.value < -dead_zone_x) {
 273           controls[LEFT] = true;
 274           controls[RIGHT] = false;
 275         } else if(event.jaxis.value > dead_zone_x) {
 276           controls[LEFT] = false;
 277           controls[RIGHT] = true;
 278         } else {
 279           controls[LEFT] = false;
 280           controls[RIGHT] = false;
 281         }
 282       } else if(event.jaxis.axis == joyaxis_y) {
 283         if(event.jaxis.value < -dead_zone_y) {
 284           controls[UP] = true;
 285           controls[DOWN] = false;
 286         } else if(event.jaxis.value > dead_zone_y) {
 287           controls[UP] = false;
 288           controls[DOWN] = true;
 289         } else {
 290           controls[UP] = false;
 291           controls[DOWN] = false;
 292         }
 293       }
 294       break;
 295
 296     case SDL_JOYHATMOTION:
 297       if(!use_hat)
 298         break;
 299
 300       if(event.jhat.value & SDL_HAT_UP) {
 301         controls[UP] = true;
 302         controls[DOWN] = false;
 303       }
 304       if(event.jhat.value & SDL_HAT_DOWN) {
 305         controls[UP] = false;
 306         controls[DOWN] = true;
 307       }
 308       if(event.jhat.value & SDL_HAT_LEFT) {
 309         controls[LEFT] = true;
 310         controls[RIGHT] = false;
 311       }
 312       if(event.jhat.value & SDL_HAT_RIGHT) {
 313         controls[LEFT] = false;
 314         controls[RIGHT] = true;
 315       }
 316       if(event.jhat.value == SDL_HAT_CENTERED) {
 317         controls[UP] = false;
 318         controls[DOWN] = false;
 319         controls[LEFT] = false;
 320         controls[RIGHT] = false;
 321       }
 322       break;
 323
 324     case SDL_JOYBUTTONDOWN:
 325     case SDL_JOYBUTTONUP:
 326     {
 327       if(wait_for_joybutton >= 0) {
 328         if(event.type == SDL_JOYBUTTONUP)
 329           return;
 330
 331         Control c = (Control) wait_for_joybutton;
 332         reset_joybutton(event.jbutton.button, c);
 333         reset();
 334         joystick_options_menu->update();
 335         wait_for_joybutton = -1;
 336         return;
 337       }
 338
 339       ButtonMap::iterator i = joy_button_map.find(event.jbutton.button);
 340       if(i == joy_button_map.end()) {
 341         log_debug << "Unmapped joybutton " << (int)event.jbutton.button << " pressed" << std::endl;
 342         return;
 343       }
 344
 345       controls[i->second] =
 346         event.type == SDL_JOYBUTTONDOWN ? true : false;
 347       break;
 348     }
 349
 350     default:
 351       break;
 352   }
 353 }
 354
 355 void
 356 JoystickKeyboardController::process_key_event(const SDL_Event& event)
 357 {
 358   KeyMap::iterator key_mapping = keymap.find(event.key.keysym.sym);
 359
 360   // if console key was pressed: toggle console
 361   if ((key_mapping != keymap.end()) && (key_mapping->second == CONSOLE)) {
 362     if (event.type != SDL_KEYDOWN) return;
 363     Console::instance->toggle();
 364     return;
 365   }
 366
 367   // if console is open: send key there
 368   if (Console::instance->hasFocus()) {
 369     process_console_key_event(event);
 370     return;
 371   }
 372
 373   // if menu mode: send key there
 374   if (Menu::current()) {
 375     process_menu_key_event(event);
 376     return;
 377   }
 378
 379   // default action: update controls
 380   if(key_mapping == keymap.end()) {
 381     log_debug << "Key " << event.key.keysym.sym << " is unbound" << std::endl;
 382     return;
 383   }
 384   Control control = key_mapping->second;
 385   controls[control] = event.type == SDL_KEYDOWN ? true : false;
 386 }
 387
 388 void
 389 JoystickKeyboardController::process_console_key_event(const SDL_Event& event)
 390 {
 391   if (event.type != SDL_KEYDOWN) return;
 392
 393   switch (event.key.keysym.sym) {
 394     case SDLK_RETURN:
 395       Console::instance->input << std::endl;
 396       break;
 397     case SDLK_BACKSPACE:
 398       Console::instance->backspace();
 399       break;
 400     case SDLK_TAB:
 401       Console::instance->autocomplete();
 402       break;
 403     case SDLK_PAGEUP:
 404       Console::instance->scroll(-1);
 405       break;
 406     case SDLK_PAGEDOWN:
 407       Console::instance->scroll(+1);
 408       break;
 409     case SDLK_END:
 410       Console::instance->scroll(+65535);
 411       break;
 412     case SDLK_UP:
 413       Console::instance->show_history(-1);
 414       break;
 415     case SDLK_DOWN:
 416       Console::instance->show_history(+1);
 417       break;
 418     default:
 419       int c = event.key.keysym.unicode;
 420       if ((c >= 32) && (c <= 126)) {
 421         Console::instance->input << (char)c;
 422       }
 423       break;
 424   }
 425 }
 426
 427 void
 428 JoystickKeyboardController::process_menu_key_event(const SDL_Event& event)
 429 {
 430   // wait for key mode?
 431   if(wait_for_key >= 0) {
 432     if(event.type == SDL_KEYUP)
 433       return;
 434
 435     if(event.key.keysym.sym != SDLK_ESCAPE
 436         && event.key.keysym.sym != SDLK_PAUSE) {
 437       reset_key(event.key.keysym.sym, (Control) wait_for_key);
 438     }
 439     reset();
 440     key_options_menu->update();
 441     wait_for_key = -1;
 442     return;
 443   }
 444   if(wait_for_joybutton >= 0) {
 445     if(event.key.keysym.sym == SDLK_ESCAPE) {
 446       reset();
 447       joystick_options_menu->update();
 448       wait_for_joybutton = -1;
 449     }
 450     return;
 451   }
 452
 453   Control control;
 454   /* we use default keys when the menu is open (to avoid problems when
 455    * redefining keys to invalid settings
 456    */
 457   switch(event.key.keysym.sym) {
 458     case SDLK_UP:
 459       control = UP;
 460       break;
 461     case SDLK_DOWN:
 462       control = DOWN;
 463       break;
 464     case SDLK_LEFT:
 465       control = LEFT;
 466       break;
 467     case SDLK_RIGHT:
 468       control = RIGHT;
 469       break;
 470     case SDLK_SPACE:
 471     case SDLK_RETURN:
 472     case SDLK_KP_ENTER:
 473       control = MENU_SELECT;
 474       break;
 475     case SDLK_ESCAPE:
 476     case SDLK_PAUSE:
 477       control = PAUSE_MENU;
 478       break;
 479     default:
 480       return;
 481       break;
 482   }
 483
 484   controls[control] = event.type == SDL_KEYDOWN ? true : false;
 485 }
 486
 487 void
 488 JoystickKeyboardController::reset_joybutton(int button, Control control)
 489 {
 490   // remove all previous mappings for that control and for that key
 491   for(ButtonMap::iterator i = joy_button_map.begin();
 492       i != joy_button_map.end(); /* no ++i */) {
 493     if(i->second == control) {
 494       ButtonMap::iterator e = i;
 495       ++i;
 496       joy_button_map.erase(e);
 497     } else {
 498       ++i;
 499     }
 500   }
 501   ButtonMap::iterator i = joy_button_map.find(button);
 502   if(i != joy_button_map.end())
 503     joy_button_map.erase(i);
 504
 505   // add new mapping
 506   joy_button_map.insert(std::make_pair(button, control));
 507
 508   // map all unused buttons to MENU_SELECT
 509   for(int b = 0; b < max_joybuttons; ++b) {
 510     ButtonMap::iterator i = joy_button_map.find(b);
 511     if(i != joy_button_map.end())
 512       continue;
 513
 514     joy_button_map.insert(std::make_pair(b, MENU_SELECT));
 515   }
 516 }
 517
 518 void
 519 JoystickKeyboardController::reset_key(SDLKey key, Control control)
 520 {
 521   // remove all previous mappings for that control and for that key
 522   for(KeyMap::iterator i = keymap.begin();
 523       i != keymap.end(); /* no ++i */) {
 524     if(i->second == control) {
 525       KeyMap::iterator e = i;
 526       ++i;
 527       keymap.erase(e);
 528     } else {
 529       ++i;
 530     }
 531   }
 532   KeyMap::iterator i = keymap.find(key);
 533   if(i != keymap.end())
 534     keymap.erase(i);
 535
 536   // add new mapping
 537   keymap.insert(std::make_pair(key, control));
 538 }
 539
 540 SDLKey
 541 JoystickKeyboardController::reversemap_key(Control c)
 542 {
 543   for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
 544     if(i->second == c)
 545       return i->first;
 546   }
 547
 548   return SDLK_UNKNOWN;
 549 }
 550
 551 int
 552 JoystickKeyboardController::reversemap_joybutton(Control c)
 553 {
 554   for(ButtonMap::iterator i = joy_button_map.begin();
 555       i != joy_button_map.end(); ++i) {
 556     if(i->second == c)
 557       return i->first;
 558   }
 559
 560   return -1;
 561 }
 562
 563 Menu*
 564 JoystickKeyboardController::get_key_options_menu()
 565 {
 566   if(key_options_menu == 0) {
 567     key_options_menu = new KeyboardMenu(this);
 568   }
 569
 570   return key_options_menu;
 571 }
 572
 573 Menu*
 574 JoystickKeyboardController::get_joystick_options_menu()
 575 {
 576   if(joystick_options_menu == 0) {
 577     joystick_options_menu = new JoystickMenu(this);
 578   }
 579
 580   return joystick_options_menu;
 581 }
 582
 583 //----------------------------------------------------------------------------
 584
 585 JoystickKeyboardController::KeyboardMenu::KeyboardMenu(
 586     JoystickKeyboardController* _controller)
 587   : controller(_controller)
 588 {
 589     add_label(_("Setup Keyboard"));
 590     add_hl();
 591     add_controlfield(Controller::UP, _("Up"));
 592     add_controlfield(Controller::DOWN, _("Down"));
 593     add_controlfield(Controller::LEFT, _("Left"));
 594     add_controlfield(Controller::RIGHT, _("Right"));
 595     add_controlfield(Controller::JUMP, _("Jump"));
 596     add_controlfield(Controller::ACTION, _("Action"));
 597     add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
 598     add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
 599     add_hl();
 600     add_back(_("Back"));
 601     update();
 602 }
 603
 604 JoystickKeyboardController::KeyboardMenu::~KeyboardMenu()
 605 {}
 606
 607 std::string
 608 JoystickKeyboardController::KeyboardMenu::get_key_name(SDLKey key)
 609 {
 610   switch(key) {
 611     case SDLK_UNKNOWN:
 612       return _("None");
 613     case SDLK_UP:
 614       return _("Up cursor");
 615     case SDLK_DOWN:
 616       return _("Down cursor");
 617     case SDLK_LEFT:
 618       return _("Left cursor");
 619     case SDLK_RIGHT:
 620       return _("Right cursor");
 621     case SDLK_RETURN:
 622       return _("Return");
 623     case SDLK_SPACE:
 624       return _("Space");
 625     case SDLK_RSHIFT:
 626       return _("Right Shift");
 627     case SDLK_LSHIFT:
 628       return _("Left Shift");
 629     case SDLK_RCTRL:
 630       return _("Right Control");
 631     case SDLK_LCTRL:
 632       return _("Left Control");
 633     case SDLK_RALT:
 634       return _("Right Alt");
 635     case SDLK_LALT:
 636       return _("Left Alt");
 637     default:
 638       return SDL_GetKeyName((SDLKey) key);
 639   }
 640 }
 641
 642 void
 643 JoystickKeyboardController::KeyboardMenu::menu_action(MenuItem* item)
 644 {
 645   assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
 646   item->change_input(_("Press Key"));
 647   controller->wait_for_key = item->id;
 648 }
 649
 650 void
 651 JoystickKeyboardController::KeyboardMenu::update()
 652 {
 653   // update menu
 654   get_item_by_id((int) Controller::UP).change_input(get_key_name(
 655     controller->reversemap_key(Controller::UP)));
 656   get_item_by_id((int) Controller::DOWN).change_input(get_key_name(
 657     controller->reversemap_key(Controller::DOWN)));
 658   get_item_by_id((int) Controller::LEFT).change_input(get_key_name(
 659     controller->reversemap_key(Controller::LEFT)));
 660   get_item_by_id((int) Controller::RIGHT).change_input(get_key_name(
 661     controller->reversemap_key(Controller::RIGHT)));
 662   get_item_by_id((int) Controller::JUMP).change_input(get_key_name(
 663     controller->reversemap_key(Controller::JUMP)));
 664   get_item_by_id((int) Controller::ACTION).change_input(get_key_name(
 665     controller->reversemap_key(Controller::ACTION)));
 666   get_item_by_id((int) Controller::PEEK_LEFT).change_input(get_key_name(
 667     controller->reversemap_key(Controller::PEEK_LEFT)));
 668   get_item_by_id((int) Controller::PEEK_RIGHT).change_input(get_key_name(
 669     controller->reversemap_key(Controller::PEEK_RIGHT)));
 670 }
 671
 672 //---------------------------------------------------------------------------
 673
 674 JoystickKeyboardController::JoystickMenu::JoystickMenu(
 675   JoystickKeyboardController* _controller)
 676   : controller(_controller)
 677 {
 678   add_label(_("Setup Joystick"));
 679   add_hl();
 680   if(controller->joysticks.size() > 0) {
 681     add_controlfield(Controller::JUMP, _("Jump"));
 682     add_controlfield(Controller::ACTION, _("Action"));
 683     add_controlfield(Controller::PAUSE_MENU, _("Pause/Menu"));
 684     add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
 685     add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
 686   } else {
 687     add_deactive(-1, _("No Joysticks found"));
 688   }
 689   add_hl();
 690   add_back(_("Back"));
 691   update();
 692 }
 693
 694 JoystickKeyboardController::JoystickMenu::~JoystickMenu()
 695 {}
 696
 697 std::string
 698 JoystickKeyboardController::JoystickMenu::get_button_name(int button)
 699 {
 700   if(button < 0)
 701     return _("None");
 702
 703   std::ostringstream name;
 704   name << "Button " << button;
 705   return name.str();
 706 }
 707
 708 void
 709 JoystickKeyboardController::JoystickMenu::menu_action(MenuItem* item)
 710 {
 711   assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
 712   item->change_input(_("Press Button"));
 713   controller->wait_for_joybutton = item->id;
 714 }
 715
 716 void
 717 JoystickKeyboardController::JoystickMenu::update()
 718 {
 719   if(controller->joysticks.size() == 0)
 720     return;
 721
 722   // update menu
 723   get_item_by_id((int) Controller::JUMP).change_input(get_button_name(
 724     controller->reversemap_joybutton(Controller::JUMP)));
 725   get_item_by_id((int) Controller::ACTION).change_input(get_button_name(
 726     controller->reversemap_joybutton(Controller::ACTION)));
 727   get_item_by_id((int) Controller::PAUSE_MENU).change_input(get_button_name(
 728     controller->reversemap_joybutton(Controller::PAUSE_MENU)));
 729   get_item_by_id((int) Controller::PEEK_LEFT).change_input(get_button_name(
 730     controller->reversemap_joybutton(Controller::PEEK_LEFT)));
 731   get_item_by_id((int) Controller::PEEK_RIGHT).change_input(get_button_name(
 732     controller->reversemap_joybutton(Controller::PEEK_RIGHT)));
 733 }