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] = (event.type == SDL_JOYBUTTONDOWN);
 346       break;
 347     }
 348
 349     default:
 350       break;
 351   }
 352 }
 353
 354 void
 355 JoystickKeyboardController::process_key_event(const SDL_Event& event)
 356 {
 357   KeyMap::iterator key_mapping = keymap.find(event.key.keysym.sym);
 358
 359   // if console key was pressed: toggle console
 360   if ((key_mapping != keymap.end()) && (key_mapping->second == CONSOLE)) {
 361     if (event.type != SDL_KEYDOWN) return;
 362     Console::instance->toggle();
 363     return;
 364   }
 365
 366   // if console is open: send key there
 367   if (Console::instance->hasFocus()) {
 368     process_console_key_event(event);
 369     return;
 370   }
 371
 372   // if menu mode: send key there
 373   if (Menu::current()) {
 374     process_menu_key_event(event);
 375     return;
 376   }
 377
 378   // default action: update controls
 379   if(key_mapping == keymap.end()) {
 380     log_debug << "Key " << event.key.keysym.sym << " is unbound" << std::endl;
 381     return;
 382   }
 383   Control control = key_mapping->second;
 384   controls[control] = (event.type == SDL_KEYDOWN);
 385 }
 386
 387 void
 388 JoystickKeyboardController::process_console_key_event(const SDL_Event& event)
 389 {
 390   if (event.type != SDL_KEYDOWN) return;
 391
 392   switch (event.key.keysym.sym) {
 393     case SDLK_RETURN:
 394       Console::instance->input << std::endl;
 395       break;
 396     case SDLK_BACKSPACE:
 397       Console::instance->backspace();
 398       break;
 399     case SDLK_TAB:
 400       Console::instance->autocomplete();
 401       break;
 402     case SDLK_PAGEUP:
 403       Console::instance->scroll(-1);
 404       break;
 405     case SDLK_PAGEDOWN:
 406       Console::instance->scroll(+1);
 407       break;
 408     case SDLK_END:
 409       Console::instance->scroll(+65535);
 410       break;
 411     case SDLK_UP:
 412       Console::instance->show_history(-1);
 413       break;
 414     case SDLK_DOWN:
 415       Console::instance->show_history(+1);
 416       break;
 417     default:
 418       int c = event.key.keysym.unicode;
 419       if ((c >= 32) && (c <= 126)) {
 420         Console::instance->input << (char)c;
 421       }
 422       break;
 423   }
 424 }
 425
 426 void
 427 JoystickKeyboardController::process_menu_key_event(const SDL_Event& event)
 428 {
 429   // wait for key mode?
 430   if(wait_for_key >= 0) {
 431     if(event.type == SDL_KEYUP)
 432       return;
 433
 434     if(event.key.keysym.sym != SDLK_ESCAPE
 435         && event.key.keysym.sym != SDLK_PAUSE) {
 436       reset_key(event.key.keysym.sym, (Control) wait_for_key);
 437     }
 438     reset();
 439     key_options_menu->update();
 440     wait_for_key = -1;
 441     return;
 442   }
 443   if(wait_for_joybutton >= 0) {
 444     if(event.key.keysym.sym == SDLK_ESCAPE) {
 445       reset();
 446       joystick_options_menu->update();
 447       wait_for_joybutton = -1;
 448     }
 449     return;
 450   }
 451
 452   Control control;
 453   /* we use default keys when the menu is open (to avoid problems when
 454    * redefining keys to invalid settings
 455    */
 456   switch(event.key.keysym.sym) {
 457     case SDLK_UP:
 458       control = UP;
 459       break;
 460     case SDLK_DOWN:
 461       control = DOWN;
 462       break;
 463     case SDLK_LEFT:
 464       control = LEFT;
 465       break;
 466     case SDLK_RIGHT:
 467       control = RIGHT;
 468       break;
 469     case SDLK_SPACE:
 470     case SDLK_RETURN:
 471     case SDLK_KP_ENTER:
 472       control = MENU_SELECT;
 473       break;
 474     case SDLK_ESCAPE:
 475     case SDLK_PAUSE:
 476       control = PAUSE_MENU;
 477       break;
 478     default:
 479       return;
 480       break;
 481   }
 482
 483   controls[control] = (event.type == SDL_KEYDOWN);
 484 }
 485
 486 void
 487 JoystickKeyboardController::reset_joybutton(int button, Control control)
 488 {
 489   // remove all previous mappings for that control and for that key
 490   for(ButtonMap::iterator i = joy_button_map.begin();
 491       i != joy_button_map.end(); /* no ++i */) {
 492     if(i->second == control) {
 493       ButtonMap::iterator e = i;
 494       ++i;
 495       joy_button_map.erase(e);
 496     } else {
 497       ++i;
 498     }
 499   }
 500   ButtonMap::iterator i = joy_button_map.find(button);
 501   if(i != joy_button_map.end())
 502     joy_button_map.erase(i);
 503
 504   // add new mapping
 505   joy_button_map.insert(std::make_pair(button, control));
 506
 507   // map all unused buttons to MENU_SELECT
 508   for(int b = 0; b < max_joybuttons; ++b) {
 509     ButtonMap::iterator i = joy_button_map.find(b);
 510     if(i != joy_button_map.end())
 511       continue;
 512
 513     joy_button_map.insert(std::make_pair(b, MENU_SELECT));
 514   }
 515 }
 516
 517 void
 518 JoystickKeyboardController::reset_key(SDLKey key, Control control)
 519 {
 520   // remove all previous mappings for that control and for that key
 521   for(KeyMap::iterator i = keymap.begin();
 522       i != keymap.end(); /* no ++i */) {
 523     if(i->second == control) {
 524       KeyMap::iterator e = i;
 525       ++i;
 526       keymap.erase(e);
 527     } else {
 528       ++i;
 529     }
 530   }
 531   KeyMap::iterator i = keymap.find(key);
 532   if(i != keymap.end())
 533     keymap.erase(i);
 534
 535   // add new mapping
 536   keymap.insert(std::make_pair(key, control));
 537 }
 538
 539 SDLKey
 540 JoystickKeyboardController::reversemap_key(Control c)
 541 {
 542   for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
 543     if(i->second == c)
 544       return i->first;
 545   }
 546
 547   return SDLK_UNKNOWN;
 548 }
 549
 550 int
 551 JoystickKeyboardController::reversemap_joybutton(Control c)
 552 {
 553   for(ButtonMap::iterator i = joy_button_map.begin();
 554       i != joy_button_map.end(); ++i) {
 555     if(i->second == c)
 556       return i->first;
 557   }
 558
 559   return -1;
 560 }
 561
 562 Menu*
 563 JoystickKeyboardController::get_key_options_menu()
 564 {
 565   if(key_options_menu == 0) {
 566     key_options_menu = new KeyboardMenu(this);
 567   }
 568
 569   return key_options_menu;
 570 }
 571
 572 Menu*
 573 JoystickKeyboardController::get_joystick_options_menu()
 574 {
 575   if(joystick_options_menu == 0) {
 576     joystick_options_menu = new JoystickMenu(this);
 577   }
 578
 579   return joystick_options_menu;
 580 }
 581
 582 //----------------------------------------------------------------------------
 583
 584 JoystickKeyboardController::KeyboardMenu::KeyboardMenu(
 585     JoystickKeyboardController* _controller)
 586   : controller(_controller)
 587 {
 588     add_label(_("Setup Keyboard"));
 589     add_hl();
 590     add_controlfield(Controller::UP, _("Up"));
 591     add_controlfield(Controller::DOWN, _("Down"));
 592     add_controlfield(Controller::LEFT, _("Left"));
 593     add_controlfield(Controller::RIGHT, _("Right"));
 594     add_controlfield(Controller::JUMP, _("Jump"));
 595     add_controlfield(Controller::ACTION, _("Action"));
 596     add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
 597     add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
 598     add_hl();
 599     add_back(_("Back"));
 600     update();
 601 }
 602
 603 JoystickKeyboardController::KeyboardMenu::~KeyboardMenu()
 604 {}
 605
 606 std::string
 607 JoystickKeyboardController::KeyboardMenu::get_key_name(SDLKey key)
 608 {
 609   switch(key) {
 610     case SDLK_UNKNOWN:
 611       return _("None");
 612     case SDLK_UP:
 613       return _("Up cursor");
 614     case SDLK_DOWN:
 615       return _("Down cursor");
 616     case SDLK_LEFT:
 617       return _("Left cursor");
 618     case SDLK_RIGHT:
 619       return _("Right cursor");
 620     case SDLK_RETURN:
 621       return _("Return");
 622     case SDLK_SPACE:
 623       return _("Space");
 624     case SDLK_RSHIFT:
 625       return _("Right Shift");
 626     case SDLK_LSHIFT:
 627       return _("Left Shift");
 628     case SDLK_RCTRL:
 629       return _("Right Control");
 630     case SDLK_LCTRL:
 631       return _("Left Control");
 632     case SDLK_RALT:
 633       return _("Right Alt");
 634     case SDLK_LALT:
 635       return _("Left Alt");
 636     default:
 637       return SDL_GetKeyName((SDLKey) key);
 638   }
 639 }
 640
 641 void
 642 JoystickKeyboardController::KeyboardMenu::menu_action(MenuItem* item)
 643 {
 644   assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
 645   item->change_input(_("Press Key"));
 646   controller->wait_for_key = item->id;
 647 }
 648
 649 void
 650 JoystickKeyboardController::KeyboardMenu::update()
 651 {
 652   // update menu
 653   get_item_by_id((int) Controller::UP).change_input(get_key_name(
 654     controller->reversemap_key(Controller::UP)));
 655   get_item_by_id((int) Controller::DOWN).change_input(get_key_name(
 656     controller->reversemap_key(Controller::DOWN)));
 657   get_item_by_id((int) Controller::LEFT).change_input(get_key_name(
 658     controller->reversemap_key(Controller::LEFT)));
 659   get_item_by_id((int) Controller::RIGHT).change_input(get_key_name(
 660     controller->reversemap_key(Controller::RIGHT)));
 661   get_item_by_id((int) Controller::JUMP).change_input(get_key_name(
 662     controller->reversemap_key(Controller::JUMP)));
 663   get_item_by_id((int) Controller::ACTION).change_input(get_key_name(
 664     controller->reversemap_key(Controller::ACTION)));
 665   get_item_by_id((int) Controller::PEEK_LEFT).change_input(get_key_name(
 666     controller->reversemap_key(Controller::PEEK_LEFT)));
 667   get_item_by_id((int) Controller::PEEK_RIGHT).change_input(get_key_name(
 668     controller->reversemap_key(Controller::PEEK_RIGHT)));
 669 }
 670
 671 //---------------------------------------------------------------------------
 672
 673 JoystickKeyboardController::JoystickMenu::JoystickMenu(
 674   JoystickKeyboardController* _controller)
 675   : controller(_controller)
 676 {
 677   add_label(_("Setup Joystick"));
 678   add_hl();
 679   if(controller->joysticks.size() > 0) {
 680     add_controlfield(Controller::JUMP, _("Jump"));
 681     add_controlfield(Controller::ACTION, _("Action"));
 682     add_controlfield(Controller::PAUSE_MENU, _("Pause/Menu"));
 683     add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
 684     add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
 685   } else {
 686     add_deactive(-1, _("No Joysticks found"));
 687   }
 688   add_hl();
 689   add_back(_("Back"));
 690   update();
 691 }
 692
 693 JoystickKeyboardController::JoystickMenu::~JoystickMenu()
 694 {}
 695
 696 std::string
 697 JoystickKeyboardController::JoystickMenu::get_button_name(int button)
 698 {
 699   if(button < 0)
 700     return _("None");
 701
 702   std::ostringstream name;
 703   name << "Button " << button;
 704   return name.str();
 705 }
 706
 707 void
 708 JoystickKeyboardController::JoystickMenu::menu_action(MenuItem* item)
 709 {
 710   assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
 711   item->change_input(_("Press Button"));
 712   controller->wait_for_joybutton = item->id;
 713 }
 714
 715 void
 716 JoystickKeyboardController::JoystickMenu::update()
 717 {
 718   if(controller->joysticks.size() == 0)
 719     return;
 720
 721   // update menu
 722   get_item_by_id((int) Controller::JUMP).change_input(get_button_name(
 723     controller->reversemap_joybutton(Controller::JUMP)));
 724   get_item_by_id((int) Controller::ACTION).change_input(get_button_name(
 725     controller->reversemap_joybutton(Controller::ACTION)));
 726   get_item_by_id((int) Controller::PAUSE_MENU).change_input(get_button_name(
 727     controller->reversemap_joybutton(Controller::PAUSE_MENU)));
 728   get_item_by_id((int) Controller::PEEK_LEFT).change_input(get_button_name(
 729     controller->reversemap_joybutton(Controller::PEEK_LEFT)));
 730   get_item_by_id((int) Controller::PEEK_RIGHT).change_input(get_button_name(
 731     controller->reversemap_joybutton(Controller::PEEK_RIGHT)));
 732 }