src/control/joystickkeyboardcontroller.cpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>,
   3 //                2007 Ingo Ruhnke <grumbel@gmx.de>
   4 //
   5 //  This program is free software: you can redistribute it and/or modify
   6 //  it under the terms of the GNU General Public License as published by
   7 //  the Free Software Foundation, either version 3 of the License, or
   8 //  (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful,
  11 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 //  GNU General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 #include "control/joystickkeyboardcontroller.hpp"
  19
  20 #include <iostream>
  21
  22 #include "lisp/list_iterator.hpp"
  23 #include "gui/menu_manager.hpp"
  24 #include "supertux/console.hpp"
  25 #include "supertux/gameconfig.hpp"
  26 #include "supertux/menu/menu_storage.hpp"
  27 #include "supertux/menu/joystick_menu.hpp"
  28 #include "supertux/menu/keyboard_menu.hpp"
  29 #include "util/gettext.hpp"
  30 #include "util/writer.hpp"
  31
  32 JoystickKeyboardController::JoystickKeyboardController() :
  33   keymap(),
  34   joy_button_map(),
  35   joy_axis_map(),
  36   joy_hat_map(),
  37   joysticks(),
  38   name(),
  39   dead_zone(),
  40   min_joybuttons(),
  41   max_joybuttons(),
  42   max_joyaxis(),
  43   max_joyhats(),
  44   hat_state(0),
  45   jump_with_up_joy(),
  46   jump_with_up_kbd(),
  47   wait_for_key(-1),
  48   wait_for_joystick(-1)
  49 {
  50   // initialize default keyboard map
  51   keymap[SDLK_LEFT]     = LEFT;
  52   keymap[SDLK_RIGHT]    = RIGHT;
  53   keymap[SDLK_UP]       = UP;
  54   keymap[SDLK_DOWN]     = DOWN;
  55   keymap[SDLK_SPACE]    = JUMP;
  56   keymap[SDLK_LCTRL]    = ACTION;
  57   keymap[SDLK_LALT]     = ACTION;
  58   keymap[SDLK_ESCAPE]   = PAUSE_MENU;
  59   keymap[SDLK_p]        = PAUSE_MENU;
  60   keymap[SDLK_PAUSE]    = PAUSE_MENU;
  61   keymap[SDLK_RETURN]   = MENU_SELECT;
  62   keymap[SDLK_KP_ENTER] = MENU_SELECT;
  63   keymap[SDLK_CARET]    = CONSOLE;
  64   keymap[SDLK_DELETE]   = PEEK_LEFT;
  65   keymap[SDLK_PAGEDOWN] = PEEK_RIGHT;
  66   keymap[SDLK_HOME]     = PEEK_UP;
  67   keymap[SDLK_END]      = PEEK_DOWN;
  68
  69   jump_with_up_joy = false;
  70   jump_with_up_kbd = false;
  71
  72   updateAvailableJoysticks();
  73
  74   dead_zone = 1000;
  75
  76   // Default joystick button configuration
  77   joy_button_map[0] = JUMP;
  78   joy_button_map[1] = ACTION;
  79   // 6 or more Buttons
  80   if( min_joybuttons > 5 ){
  81     joy_button_map[4] = PEEK_LEFT;
  82     joy_button_map[5] = PEEK_RIGHT;
  83     // 8 or more
  84     if(min_joybuttons > 7)
  85       joy_button_map[min_joybuttons-1] = PAUSE_MENU;
  86   } else {
  87     // map the last 2 buttons to menu and pause
  88     if(min_joybuttons > 2)
  89       joy_button_map[min_joybuttons-1] = PAUSE_MENU;
  90     // map all remaining joystick buttons to MENU_SELECT
  91     for(int i = 2; i < max_joybuttons; ++i) {
  92       if(i != min_joybuttons-1)
  93         joy_button_map[i] = MENU_SELECT;
  94     }
  95   }
  96
  97   // Default joystick axis configuration
  98   joy_axis_map[-1] = LEFT;
  99   joy_axis_map[ 1] = RIGHT;
 100   joy_axis_map[-2] = UP;
 101   joy_axis_map[ 2] = DOWN;
 102 }
 103
 104 JoystickKeyboardController::~JoystickKeyboardController()
 105 {
 106   for(std::vector<SDL_Joystick*>::iterator i = joysticks.begin();
 107       i != joysticks.end(); ++i) {
 108     if(*i != 0)
 109       SDL_JoystickClose(*i);
 110   }
 111 }
 112
 113 void
 114 JoystickKeyboardController::updateAvailableJoysticks()
 115 {
 116   for(std::vector<SDL_Joystick*>::iterator i = joysticks.begin();
 117       i != joysticks.end(); ++i) {
 118     if(*i != 0)
 119       SDL_JoystickClose(*i);
 120   }
 121   joysticks.clear();
 122
 123   SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
 124   SDL_InitSubSystem(SDL_INIT_JOYSTICK);
 125
 126   int joystick_count = SDL_NumJoysticks();
 127   min_joybuttons = -1;
 128   max_joybuttons = -1;
 129   max_joyaxis    = -1;
 130   max_joyhats    = -1;
 131
 132   if( joystick_count > 0 ){
 133     for(int i = 0; i < joystick_count; ++i) {
 134       SDL_Joystick* joystick = SDL_JoystickOpen(i);
 135       bool good = true;
 136       if(SDL_JoystickNumButtons(joystick) < 2) {
 137         log_info << "Joystick " << i << ": " << SDL_JoystickName(i) << " has less than 2 buttons" << std::endl;
 138         good = false;
 139       }
 140       if(SDL_JoystickNumAxes(joystick) < 2
 141          && SDL_JoystickNumHats(joystick) == 0) {
 142         log_info << "Joystick " << i << ": " << SDL_JoystickName(i) << " has less than 2 axes and no hat" << std::endl;
 143         good = false;
 144       }
 145       if(!good) {
 146         SDL_JoystickClose(joystick);
 147         continue;
 148       }
 149
 150       if(min_joybuttons < 0 || SDL_JoystickNumButtons(joystick) < min_joybuttons)
 151         min_joybuttons = SDL_JoystickNumButtons(joystick);
 152
 153       if(SDL_JoystickNumButtons(joystick) > max_joybuttons)
 154         max_joybuttons = SDL_JoystickNumButtons(joystick);
 155
 156       if(SDL_JoystickNumAxes(joystick) > max_joyaxis)
 157         max_joyaxis = SDL_JoystickNumAxes(joystick);
 158
 159       if(SDL_JoystickNumHats(joystick) > max_joyhats)
 160         max_joyhats = SDL_JoystickNumHats(joystick);
 161
 162       joysticks.push_back(joystick);
 163     }
 164   }
 165
 166   // some joysticks or SDL seem to produce some bogus events after being opened
 167   Uint32 ticks = SDL_GetTicks();
 168   while(SDL_GetTicks() - ticks < 200) {
 169     SDL_Event event;
 170     SDL_PollEvent(&event);
 171   }
 172 }
 173
 174 void
 175 JoystickKeyboardController::read(const Reader& lisp)
 176 {
 177   const lisp::Lisp* keymap_lisp = lisp.get_lisp("keymap");
 178   if(keymap_lisp) {
 179     keymap.clear();
 180     keymap_lisp->get("jump-with-up", jump_with_up_kbd);
 181     lisp::ListIterator iter(keymap_lisp);
 182     while(iter.next()) {
 183       if(iter.item() == "map") {
 184         int key = -1;
 185         std::string control;
 186         const lisp::Lisp* map = iter.lisp();
 187         map->get("key", key);
 188         map->get("control", control);
 189 #if SDL_VERSION_ATLEAST(1,3,0)
 190         if(key < 0)
 191 #else
 192         if(key < SDLK_FIRST || key >= SDLK_LAST)
 193 #endif
 194         {
 195           log_info << "Invalid key '" << key << "' in keymap" << std::endl;
 196           continue;
 197         }
 198
 199         int i = 0;
 200         for(i = 0; controlNames[i] != 0; ++i) {
 201           if(control == controlNames[i])
 202             break;
 203         }
 204         if(controlNames[i] == 0) {
 205           log_info << "Invalid control '" << control << "' in keymap" << std::endl;
 206           continue;
 207         }
 208         keymap[(SDLKey) key] = (Control)i;
 209       }
 210     }
 211   }
 212
 213   const lisp::Lisp* joystick_lisp = lisp.get_lisp("joystick");
 214   if(joystick_lisp) {
 215     joystick_lisp->get("dead-zone", dead_zone);
 216     joystick_lisp->get("jump-with-up", jump_with_up_joy);
 217     lisp::ListIterator iter(joystick_lisp);
 218     while(iter.next()) {
 219       if(iter.item() == "map") {
 220         int button = -1;
 221         int axis   = 0;
 222         int hat    = -1;
 223         std::string control;
 224         const lisp::Lisp* map = iter.lisp();
 225
 226         map->get("control", control);
 227         int i = 0;
 228         for(i = 0; controlNames[i] != 0; ++i) {
 229           if(control == controlNames[i])
 230             break;
 231         }
 232         if(controlNames[i] == 0) {
 233           log_info << "Invalid control '" << control << "' in buttonmap" << std::endl;
 234           continue;
 235         }
 236
 237         if (map->get("button", button)) {
 238           if(button < 0 || button >= max_joybuttons) {
 239             log_info << "Invalid button '" << button << "' in buttonmap" << std::endl;
 240             continue;
 241           }
 242           bind_joybutton(button, (Control) i);
 243         }
 244
 245         if (map->get("axis",   axis)) {
 246           if (axis == 0 || abs(axis) > max_joyaxis) {
 247             log_info << "Invalid axis '" << axis << "' in axismap" << std::endl;
 248             continue;
 249           }
 250           bind_joyaxis(axis, (Control) i);
 251         }
 252
 253         if (map->get("hat",   hat)) {
 254           if (hat != SDL_HAT_UP   &&
 255               hat != SDL_HAT_DOWN &&
 256               hat != SDL_HAT_LEFT &&
 257               hat != SDL_HAT_RIGHT) {
 258             log_info << "Invalid axis '" << axis << "' in axismap" << std::endl;
 259             continue;
 260           } else {
 261             bind_joyhat(hat, (Control) i);
 262           }
 263         }
 264       }
 265     }
 266   }
 267 }
 268
 269 void
 270 JoystickKeyboardController::write(Writer& writer)
 271 {
 272   writer.start_list("keymap");
 273   writer.write("jump-with-up", jump_with_up_kbd);
 274   for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
 275     writer.start_list("map");
 276     writer.write("key", (int) i->first);
 277     writer.write("control", controlNames[i->second]);
 278     writer.end_list("map");
 279   }
 280   writer.end_list("keymap");
 281
 282   writer.start_list("joystick");
 283   writer.write("dead-zone", dead_zone);
 284   writer.write("jump-with-up", jump_with_up_joy);
 285
 286   for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end();
 287       ++i) {
 288     writer.start_list("map");
 289     writer.write("button", i->first);
 290     writer.write("control", controlNames[i->second]);
 291     writer.end_list("map");
 292   }
 293
 294   for(HatMap::iterator i = joy_hat_map.begin(); i != joy_hat_map.end(); ++i) {
 295     writer.start_list("map");
 296     writer.write("hat", i->first);
 297     writer.write("control", controlNames[i->second]);
 298     writer.end_list("map");
 299   }
 300
 301   for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); ++i) {
 302     writer.start_list("map");
 303     writer.write("axis", i->first);
 304     writer.write("control", controlNames[i->second]);
 305     writer.end_list("map");
 306   }
 307
 308   writer.end_list("joystick");
 309 }
 310
 311 void
 312 JoystickKeyboardController::reset()
 313 {
 314   Controller::reset();
 315 }
 316
 317 void
 318 JoystickKeyboardController::set_joy_controls(Control id, bool value)
 319 {
 320   if (jump_with_up_joy && id == Controller::UP)
 321     controls[Controller::JUMP] = value;
 322
 323   controls[(Control)id] = value;
 324 }
 325
 326 void
 327 JoystickKeyboardController::process_event(const SDL_Event& event)
 328 {
 329   switch(event.type) {
 330     case SDL_KEYUP:
 331     case SDL_KEYDOWN:
 332       process_key_event(event);
 333       break;
 334
 335     case SDL_JOYAXISMOTION:
 336       process_axis_event(event.jaxis);
 337       break;
 338
 339     case SDL_JOYHATMOTION:
 340       process_hat_event(event.jhat);
 341       break;
 342
 343     case SDL_JOYBUTTONDOWN:
 344     case SDL_JOYBUTTONUP:
 345       process_button_event(event.jbutton);
 346       break;
 347
 348     default:
 349       break;
 350   }
 351 }
 352
 353 void
 354 JoystickKeyboardController::process_button_event(const SDL_JoyButtonEvent& jbutton)
 355 {
 356   if(wait_for_joystick >= 0)
 357   {
 358     if(jbutton.state == SDL_PRESSED)
 359     {
 360       bind_joybutton(jbutton.button, (Control)wait_for_joystick);
 361       MenuStorage::get_joystick_options_menu()->update();
 362       reset();
 363       wait_for_joystick = -1;
 364     }
 365   }
 366   else
 367   {
 368     ButtonMap::iterator i = joy_button_map.find(jbutton.button);
 369     if(i == joy_button_map.end()) {
 370       log_debug << "Unmapped joybutton " << (int)jbutton.button << " pressed" << std::endl;
 371     } else {
 372       set_joy_controls(i->second, (jbutton.state == SDL_PRESSED));
 373     }
 374   }
 375 }
 376
 377 void
 378 JoystickKeyboardController::process_axis_event(const SDL_JoyAxisEvent& jaxis)
 379 {
 380   if (wait_for_joystick >= 0)
 381   {
 382     if (abs(jaxis.value) > dead_zone) {
 383       if (jaxis.value < 0)
 384         bind_joyaxis(-(jaxis.axis + 1), Control(wait_for_joystick));
 385       else
 386         bind_joyaxis(jaxis.axis + 1, Control(wait_for_joystick));
 387
 388       MenuStorage::get_joystick_options_menu()->update();
 389       wait_for_joystick = -1;
 390     }
 391   }
 392   else
 393   {
 394     // Split the axis into left and right, so that both can be
 395     // mapped separately (needed for jump/down vs up/down)
 396     int axis = jaxis.axis + 1;
 397
 398     AxisMap::iterator left  = joy_axis_map.find(-axis);
 399     AxisMap::iterator right = joy_axis_map.find(axis);
 400
 401     if(left == joy_axis_map.end()) {
 402       std::cout << "Unmapped joyaxis " << (int)jaxis.axis << " moved" << std::endl;
 403     } else {
 404       if (jaxis.value < -dead_zone)
 405         set_joy_controls(left->second,  true);
 406       else if (jaxis.value > dead_zone)
 407         set_joy_controls(left->second, false);
 408       else
 409         set_joy_controls(left->second, false);
 410     }
 411
 412     if(right == joy_axis_map.end()) {
 413       std::cout << "Unmapped joyaxis " << (int)jaxis.axis << " moved" << std::endl;
 414     } else {
 415       if (jaxis.value < -dead_zone)
 416         set_joy_controls(right->second, false);
 417       else if (jaxis.value > dead_zone)
 418         set_joy_controls(right->second, true);
 419       else
 420         set_joy_controls(right->second, false);
 421     }
 422   }
 423 }
 424
 425 void
 426 JoystickKeyboardController::process_hat_event(const SDL_JoyHatEvent& jhat)
 427 {
 428   Uint8 changed = hat_state ^ jhat.value;
 429
 430   if (wait_for_joystick >= 0)
 431   {
 432     if (changed & SDL_HAT_UP && jhat.value & SDL_HAT_UP)
 433       bind_joyhat(SDL_HAT_UP, (Control)wait_for_joystick);
 434
 435     if (changed & SDL_HAT_DOWN && jhat.value & SDL_HAT_DOWN)
 436       bind_joyhat(SDL_HAT_DOWN, (Control)wait_for_joystick);
 437
 438     if (changed & SDL_HAT_LEFT && jhat.value & SDL_HAT_LEFT)
 439       bind_joyhat(SDL_HAT_LEFT, (Control)wait_for_joystick);
 440
 441     if (changed & SDL_HAT_RIGHT && jhat.value & SDL_HAT_RIGHT)
 442       bind_joyhat(SDL_HAT_RIGHT, (Control)wait_for_joystick);
 443
 444     MenuStorage::get_joystick_options_menu()->update();
 445     wait_for_joystick = -1;
 446   }
 447   else
 448   {
 449     if (changed & SDL_HAT_UP)
 450     {
 451       HatMap::iterator it = joy_hat_map.find(SDL_HAT_UP);
 452       if (it != joy_hat_map.end())
 453         set_joy_controls(it->second, jhat.value & SDL_HAT_UP);
 454     }
 455
 456     if (changed & SDL_HAT_DOWN)
 457     {
 458       HatMap::iterator it = joy_hat_map.find(SDL_HAT_DOWN);
 459       if (it != joy_hat_map.end())
 460         set_joy_controls(it->second, jhat.value & SDL_HAT_DOWN);
 461     }
 462
 463     if (changed & SDL_HAT_LEFT)
 464     {
 465       HatMap::iterator it = joy_hat_map.find(SDL_HAT_LEFT);
 466       if (it != joy_hat_map.end())
 467         set_joy_controls(it->second, jhat.value & SDL_HAT_LEFT);
 468     }
 469
 470     if (changed & SDL_HAT_RIGHT)
 471     {
 472       HatMap::iterator it = joy_hat_map.find(SDL_HAT_RIGHT);
 473       if (it != joy_hat_map.end())
 474         set_joy_controls(it->second, jhat.value & SDL_HAT_RIGHT);
 475     }
 476   }
 477
 478   hat_state = jhat.value;
 479 }
 480
 481 void
 482 JoystickKeyboardController::process_key_event(const SDL_Event& event)
 483 {
 484   KeyMap::iterator key_mapping = keymap.find(event.key.keysym.sym);
 485
 486   // if console key was pressed: toggle console
 487   if ((key_mapping != keymap.end()) && (key_mapping->second == CONSOLE)) {
 488     if (event.type == SDL_KEYDOWN)
 489       Console::instance->toggle();
 490   } else {
 491     if (Console::instance->hasFocus()) {
 492       // if console is open: send key there
 493       process_console_key_event(event);
 494     } else if (MenuManager::current()) {
 495       // if menu mode: send key there
 496       process_menu_key_event(event);
 497     } else if(key_mapping == keymap.end()) {
 498       // default action: update controls
 499       //log_debug << "Key " << event.key.keysym.sym << " is unbound" << std::endl;
 500     } else {
 501       Control control = key_mapping->second;
 502       controls[control] = (event.type == SDL_KEYDOWN);
 503       if (jump_with_up_kbd && control == UP){
 504         controls[JUMP] = (event.type == SDL_KEYDOWN);
 505       }
 506     }
 507   }
 508 }
 509
 510 void
 511 JoystickKeyboardController::process_console_key_event(const SDL_Event& event)
 512 {
 513   if (event.type != SDL_KEYDOWN) return;
 514
 515   switch (event.key.keysym.sym) {
 516     case SDLK_RETURN:
 517       Console::instance->enter();
 518       break;
 519     case SDLK_BACKSPACE:
 520       Console::instance->backspace();
 521       break;
 522     case SDLK_TAB:
 523       Console::instance->autocomplete();
 524       break;
 525     case SDLK_PAGEUP:
 526       Console::instance->scroll(-1);
 527       break;
 528     case SDLK_PAGEDOWN:
 529       Console::instance->scroll(+1);
 530       break;
 531     case SDLK_HOME:
 532       Console::instance->move_cursor(-65535);
 533       break;
 534     case SDLK_END:
 535       Console::instance->move_cursor(+65535);
 536       break;
 537     case SDLK_UP:
 538       Console::instance->show_history(-1);
 539       break;
 540     case SDLK_DOWN:
 541       Console::instance->show_history(+1);
 542       break;
 543     case SDLK_LEFT:
 544       Console::instance->move_cursor(-1);
 545       break;
 546     case SDLK_RIGHT:
 547       Console::instance->move_cursor(+1);
 548       break;
 549     default:
 550       int c = event.key.keysym.unicode;
 551       if ((c >= 32) && (c <= 126)) {
 552         Console::instance->input((char)c);
 553       }
 554       break;
 555   }
 556 }
 557
 558 void
 559 JoystickKeyboardController::process_menu_key_event(const SDL_Event& event)
 560 {
 561   // wait for key mode?
 562   if(wait_for_key >= 0) {
 563     if(event.type == SDL_KEYUP)
 564       return;
 565
 566     if(event.key.keysym.sym != SDLK_ESCAPE
 567        && event.key.keysym.sym != SDLK_PAUSE) {
 568       bind_key(event.key.keysym.sym, (Control) wait_for_key);
 569     }
 570     reset();
 571     MenuStorage::get_key_options_menu()->update();
 572     wait_for_key = -1;
 573     return;
 574   }
 575   if(wait_for_joystick >= 0) {
 576     if(event.key.keysym.sym == SDLK_ESCAPE) {
 577       reset();
 578       MenuStorage::get_joystick_options_menu()->update();
 579       wait_for_joystick = -1;
 580     }
 581     return;
 582   }
 583
 584   Control control;
 585   /* we use default keys when the menu is open (to avoid problems when
 586    * redefining keys to invalid settings
 587    */
 588   switch(event.key.keysym.sym) {
 589     case SDLK_UP:
 590       control = UP;
 591       break;
 592     case SDLK_DOWN:
 593       control = DOWN;
 594       break;
 595     case SDLK_LEFT:
 596       control = LEFT;
 597       break;
 598     case SDLK_RIGHT:
 599       control = RIGHT;
 600       break;
 601     case SDLK_SPACE:
 602     case SDLK_RETURN:
 603     case SDLK_KP_ENTER:
 604       control = MENU_SELECT;
 605       break;
 606     case SDLK_ESCAPE:
 607     case SDLK_PAUSE:
 608       control = PAUSE_MENU;
 609       break;
 610     default:
 611       return;
 612       break;
 613   }
 614
 615   controls[control] = (event.type == SDL_KEYDOWN);
 616 }
 617
 618 void
 619 JoystickKeyboardController::unbind_joystick_control(Control control)
 620 {
 621   // remove all previous mappings for that control
 622   for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); /* no ++i */) {
 623     if(i->second == control)
 624       joy_axis_map.erase(i++);
 625     else
 626       ++i;
 627   }
 628
 629   for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end(); /* no ++i */) {
 630     if(i->second == control)
 631       joy_button_map.erase(i++);
 632     else
 633       ++i;
 634   }
 635
 636   for(HatMap::iterator i = joy_hat_map.begin();  i != joy_hat_map.end(); /* no ++i */) {
 637     if(i->second == control)
 638       joy_hat_map.erase(i++);
 639     else
 640       ++i;
 641   }
 642 }
 643
 644 void
 645 JoystickKeyboardController::bind_joyaxis(int axis, Control control)
 646 {
 647   // axis isn't the SDL axis number, but axisnumber + 1 with sign
 648   // changed depending on if the positive or negative end is to be
 649   // used (negative axis 0 becomes -1, positive axis 2 becomes +3,
 650   // etc.)
 651
 652   unbind_joystick_control(control);
 653
 654   // add new mapping
 655   joy_axis_map[axis] = control;
 656 }
 657
 658 void
 659 JoystickKeyboardController::bind_joyhat(int dir, Control c)
 660 {
 661   unbind_joystick_control(c);
 662
 663   // add new mapping
 664   joy_hat_map[dir] = c;
 665 }
 666
 667 void
 668 JoystickKeyboardController::bind_joybutton(int button, Control control)
 669 {
 670   unbind_joystick_control(control);
 671
 672   // add new mapping
 673   joy_button_map[button] = control;
 674 }
 675
 676 void
 677 JoystickKeyboardController::bind_key(SDLKey key, Control control)
 678 {
 679   // remove all previous mappings for that control and for that key
 680   for(KeyMap::iterator i = keymap.begin();
 681       i != keymap.end(); /* no ++i */) {
 682     if(i->second == control) {
 683       KeyMap::iterator e = i;
 684       ++i;
 685       keymap.erase(e);
 686     } else {
 687       ++i;
 688     }
 689   }
 690
 691   KeyMap::iterator i = keymap.find(key);
 692   if(i != keymap.end())
 693     keymap.erase(i);
 694
 695   // add new mapping
 696   keymap[key]= control;
 697 }
 698
 699 void
 700 JoystickKeyboardController::print_joystick_mappings()
 701 {
 702   std::cout << "Joystick Mappings" << std::endl;
 703   std::cout << "-----------------" << std::endl;
 704   for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); ++i) {
 705     std::cout << "Axis: " << i->first << " -> " << i->second << std::endl;
 706   }
 707
 708   for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end(); ++i) {
 709     std::cout << "Button: " << i->first << " -> " << i->second << std::endl;
 710   }
 711
 712   for(HatMap::iterator i = joy_hat_map.begin(); i != joy_hat_map.end(); ++i) {
 713     std::cout << "Hat: " << i->first << " -> " << i->second << std::endl;
 714   }
 715   std::cout << std::endl;
 716 }
 717
 718 SDLKey
 719 JoystickKeyboardController::reversemap_key(Control c)
 720 {
 721   for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
 722     if(i->second == c)
 723       return i->first;
 724   }
 725
 726   return SDLK_UNKNOWN;
 727 }
 728
 729 int
 730 JoystickKeyboardController::reversemap_joyaxis(Control c)
 731 {
 732   for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); ++i) {
 733     if(i->second == c)
 734       return i->first;
 735   }
 736
 737   return 0;
 738 }
 739
 740 int
 741 JoystickKeyboardController::reversemap_joybutton(Control c)
 742 {
 743   for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end(); ++i) {
 744     if(i->second == c)
 745       return i->first;
 746   }
 747
 748   return -1;
 749 }
 750
 751 int
 752 JoystickKeyboardController::reversemap_joyhat(Control c)
 753 {
 754   for(HatMap::iterator i = joy_hat_map.begin(); i != joy_hat_map.end(); ++i) {
 755     if(i->second == c)
 756       return i->first;
 757   }
 758
 759   return -1;
 760 }
 761
 762 /* EOF */