4 // Copyright (C) 2006 Matthias Braun <matze@braunis.de>,
5 // 2007 Ingo Ruhnke <grumbel@gmx.de>
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License
9 // as published by the Free Software Foundation; either version 2
10 // of the License, or (at your option) any later version.
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 #include "joystickkeyboardcontroller.hpp"
26 #include "gui/menu.hpp"
27 #include "gettext.hpp"
28 #include "lisp/lisp.hpp"
29 #include "lisp/list_iterator.hpp"
30 #include "game_session.hpp"
31 #include "console.hpp"
32 #include "gameconfig.hpp"
34 class JoystickKeyboardController::JoystickMenu : public Menu
37 JoystickMenu(JoystickKeyboardController* controller);
38 virtual ~JoystickMenu();
41 std::string get_button_name(int button);
42 void update_menu_item(Control id);
43 virtual void menu_action(MenuItem* item);
44 JoystickKeyboardController* controller;
47 class JoystickKeyboardController::KeyboardMenu : public Menu
50 KeyboardMenu(JoystickKeyboardController* controller);
54 std::string get_key_name(SDLKey key);
55 virtual void menu_action(MenuItem* item);
56 JoystickKeyboardController* controller;
59 JoystickKeyboardController::JoystickKeyboardController()
61 wait_for_key(-1), wait_for_joystick(-1),
62 key_options_menu(0), joystick_options_menu(0)
64 // initialize default keyboard map
65 keymap.insert(std::make_pair(SDLK_LEFT, LEFT));
66 keymap.insert(std::make_pair(SDLK_RIGHT, RIGHT));
67 keymap.insert(std::make_pair(SDLK_UP, UP));
68 keymap.insert(std::make_pair(SDLK_DOWN, DOWN));
69 keymap.insert(std::make_pair(SDLK_SPACE, JUMP));
70 keymap.insert(std::make_pair(SDLK_LCTRL, ACTION));
71 keymap.insert(std::make_pair(SDLK_LALT, ACTION));
72 keymap.insert(std::make_pair(SDLK_ESCAPE, PAUSE_MENU));
73 keymap.insert(std::make_pair(SDLK_p, PAUSE_MENU));
74 keymap.insert(std::make_pair(SDLK_PAUSE, PAUSE_MENU));
75 keymap.insert(std::make_pair(SDLK_RETURN, MENU_SELECT));
76 keymap.insert(std::make_pair(SDLK_KP_ENTER, MENU_SELECT));
77 keymap.insert(std::make_pair(SDLK_CARET, CONSOLE));
78 keymap.insert(std::make_pair(SDLK_DELETE, PEEK_LEFT));
79 keymap.insert(std::make_pair(SDLK_END, PEEK_RIGHT));
81 int joystick_count = SDL_NumJoysticks();
87 for(int i = 0; i < joystick_count; ++i) {
88 SDL_Joystick* joystick = SDL_JoystickOpen(i);
90 if(SDL_JoystickNumButtons(joystick) < 2) {
91 log_info << "Joystick " << i << " has less than 2 buttons" << std::endl;
94 if(SDL_JoystickNumAxes(joystick) < 2
95 && SDL_JoystickNumHats(joystick) == 0) {
96 log_info << "Joystick " << i << " has less than 2 axes and no hat" << std::endl;
100 SDL_JoystickClose(joystick);
104 if(min_joybuttons < 0 || SDL_JoystickNumButtons(joystick) < min_joybuttons)
105 min_joybuttons = SDL_JoystickNumButtons(joystick);
107 if(SDL_JoystickNumButtons(joystick) > max_joybuttons)
108 max_joybuttons = SDL_JoystickNumButtons(joystick);
110 if(SDL_JoystickNumAxes(joystick) > max_joyaxis)
111 max_joyaxis = SDL_JoystickNumAxes(joystick);
113 if(SDL_JoystickNumHats(joystick) > max_joyhats)
114 max_joyhats = SDL_JoystickNumHats(joystick);
116 joysticks.push_back(joystick);
121 // Default joystick button configuration
122 joy_button_map.insert(std::make_pair(0, JUMP));
123 joy_button_map.insert(std::make_pair(1, ACTION));
125 if( min_joybuttons > 5 ){
126 joy_button_map.insert(std::make_pair( 4, PEEK_LEFT));
127 joy_button_map.insert(std::make_pair( 5, PEEK_RIGHT));
129 if(min_joybuttons > 7)
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 && i !=4 && i!= 5 )
134 joy_button_map.insert(std::make_pair(i, MENU_SELECT));
138 // map the last 2 buttons to menu and pause
139 if(min_joybuttons > 2)
140 joy_button_map.insert(std::make_pair(min_joybuttons-1, PAUSE_MENU));
141 // map all remaining joystick buttons to MENU_SELECT
142 for(int i = 2; i < max_joybuttons; ++i) {
143 if(i != min_joybuttons-1)
144 joy_button_map.insert(std::make_pair(i, MENU_SELECT));
148 // Default joystick axis configuration
149 joy_axis_map.insert(std::make_pair(-1, LEFT));
150 joy_axis_map.insert(std::make_pair( 1, RIGHT));
151 joy_axis_map.insert(std::make_pair(-2, UP));
152 joy_axis_map.insert(std::make_pair( 2, DOWN));
154 // some joysticks or SDL seem to produce some bogus events after being opened
155 Uint32 ticks = SDL_GetTicks();
156 while(SDL_GetTicks() - ticks < 200) {
158 SDL_PollEvent(&event);
162 JoystickKeyboardController::~JoystickKeyboardController()
164 for(std::vector<SDL_Joystick*>::iterator i = joysticks.begin();
165 i != joysticks.end(); ++i) {
167 SDL_JoystickClose(*i);
170 delete key_options_menu;
171 delete joystick_options_menu;
175 JoystickKeyboardController::read(const lisp::Lisp& lisp)
177 const lisp::Lisp* keymap_lisp = lisp.get_lisp("keymap");
180 lisp::ListIterator iter(keymap_lisp);
182 if(iter.item() == "map") {
185 const lisp::Lisp* map = iter.lisp();
186 map->get("key", key);
187 map->get("control", control);
188 if(key < SDLK_FIRST || key >= SDLK_LAST) {
189 log_info << "Invalid key '" << key << "' in keymap" << std::endl;
194 for(i = 0; controlNames[i] != 0; ++i) {
195 if(control == controlNames[i])
198 if(controlNames[i] == 0) {
199 log_info << "Invalid control '" << control << "' in keymap" << std::endl;
202 keymap.insert(std::make_pair((SDLKey) key, (Control) i));
204 log_info << "Invalid lisp element '" << iter.item() << "' in keymap" << std::endl;
209 const lisp::Lisp* joystick_lisp = lisp.get_lisp("joystick");
211 joystick_lisp->get("dead_zone", dead_zone);
212 lisp::ListIterator iter(joystick_lisp);
214 if(iter.item() == "map") {
219 const lisp::Lisp* map = iter.lisp();
221 map->get("control", control);
223 for(i = 0; controlNames[i] != 0; ++i) {
224 if(control == controlNames[i])
227 if(controlNames[i] == 0) {
228 log_info << "Invalid control '" << control << "' in buttonmap" << std::endl;
232 if (map->get("button", button)) {
233 if(button < 0 || button >= max_joybuttons) {
234 log_info << "Invalid button '" << button << "' in buttonmap" << std::endl;
237 reset_joybutton(button, (Control) i);
240 if (map->get("axis", axis)) {
241 if (axis == 0 || abs(axis) > max_joyaxis) {
242 log_info << "Invalid axis '" << axis << "' in axismap" << std::endl;
245 reset_joyaxis(axis, (Control) i);
248 if (map->get("hat", hat)) {
249 if (hat != SDL_HAT_UP &&
250 hat != SDL_HAT_DOWN &&
251 hat != SDL_HAT_LEFT &&
252 hat != SDL_HAT_RIGHT) {
253 log_info << "Invalid axis '" << axis << "' in axismap" << std::endl;
256 reset_joyhat(hat, (Control) i);
265 JoystickKeyboardController::write(lisp::Writer& writer)
267 writer.start_list("keymap");
268 for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
269 writer.start_list("map");
270 writer.write_int("key", (int) i->first);
271 writer.write_string("control", controlNames[i->second]);
272 writer.end_list("map");
274 writer.end_list("keymap");
276 writer.start_list("joystick");
277 writer.write_int("dead_zone", dead_zone);
279 for(ButtonMap::iterator i = joy_button_map.begin(); i != joy_button_map.end();
281 writer.start_list("map");
282 writer.write_int("button", i->first);
283 writer.write_string("control", controlNames[i->second]);
284 writer.end_list("map");
287 for(HatMap::iterator i = joy_hat_map.begin(); i != joy_hat_map.end(); ++i) {
288 writer.start_list("map");
289 writer.write_int("hat", i->first);
290 writer.write_string("control", controlNames[i->second]);
291 writer.end_list("map");
294 for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); ++i) {
295 writer.start_list("map");
296 writer.write_int("axis", i->first);
297 writer.write_string("control", controlNames[i->second]);
298 writer.end_list("map");
301 writer.end_list("joystick");
305 JoystickKeyboardController::reset()
311 JoystickKeyboardController::process_event(const SDL_Event& event)
316 process_key_event(event);
319 case SDL_JOYAXISMOTION:
320 process_axis_event(event.jaxis);
323 case SDL_JOYHATMOTION:
324 process_hat_event(event.jhat);
327 case SDL_JOYBUTTONDOWN:
328 case SDL_JOYBUTTONUP:
330 if(wait_for_joystick >= 0) {
331 if(event.type == SDL_JOYBUTTONUP)
334 Control c = (Control) wait_for_joystick;
335 reset_joybutton(event.jbutton.button, c);
337 joystick_options_menu->update();
338 wait_for_joystick = -1;
342 ButtonMap::iterator i = joy_button_map.find(event.jbutton.button);
343 if(i == joy_button_map.end()) {
344 log_debug << "Unmapped joybutton " << (int)event.jbutton.button << " pressed" << std::endl;
348 controls[i->second] = (event.type == SDL_JOYBUTTONDOWN);
358 JoystickKeyboardController::process_axis_event(const SDL_JoyAxisEvent& jaxis)
360 if (wait_for_joystick >= 0)
362 if (abs(jaxis.value) > dead_zone)
365 reset_joyaxis(-(jaxis.axis + 1), Control(wait_for_joystick));
367 reset_joyaxis(jaxis.axis + 1, Control(wait_for_joystick));
369 joystick_options_menu->update();
370 wait_for_joystick = -1;
375 // Split the axis into left and right, so that both can be
376 // mapped seperatly (needed for jump/down vs up/down)
377 int axis = jaxis.axis + 1;
379 AxisMap::iterator left = joy_axis_map.find(-axis);
380 AxisMap::iterator right = joy_axis_map.find(axis);
382 if(left == joy_axis_map.end()) {
383 std::cout << "Unmapped joyaxis " << (int)jaxis.axis << " moved" << std::endl;
385 if (jaxis.value < -dead_zone)
386 controls[left->second] = true;
387 else if (jaxis.value > dead_zone)
388 controls[left->second] = false;
390 controls[left->second] = false;
393 if(right == joy_axis_map.end()) {
394 std::cout << "Unmapped joyaxis " << (int)jaxis.axis << " moved" << std::endl;
396 if (jaxis.value < -dead_zone)
397 controls[right->second] = false;
398 else if (jaxis.value > dead_zone)
399 controls[right->second] = true;
401 controls[right->second] = false;
407 JoystickKeyboardController::process_hat_event(const SDL_JoyHatEvent& jhat)
409 Uint8 changed = hat_state ^ jhat.value;
411 if (wait_for_joystick >= 0)
413 if (changed & SDL_HAT_UP && jhat.value & SDL_HAT_UP)
414 reset_joyhat(SDL_HAT_UP, (Control)wait_for_joystick);
416 if (changed & SDL_HAT_DOWN && jhat.value & SDL_HAT_DOWN)
417 reset_joyhat(SDL_HAT_DOWN, (Control)wait_for_joystick);
419 if (changed & SDL_HAT_LEFT && jhat.value & SDL_HAT_LEFT)
420 reset_joyhat(SDL_HAT_LEFT, (Control)wait_for_joystick);
422 if (changed & SDL_HAT_RIGHT && jhat.value & SDL_HAT_RIGHT)
423 reset_joyhat(SDL_HAT_RIGHT, (Control)wait_for_joystick);
425 joystick_options_menu->update();
426 wait_for_joystick = -1;
430 if (changed & SDL_HAT_UP)
432 HatMap::iterator it = joy_hat_map.find(SDL_HAT_UP);
433 if (it != joy_hat_map.end())
434 controls[it->second] = jhat.value & SDL_HAT_UP;
437 if (changed & SDL_HAT_DOWN)
439 HatMap::iterator it = joy_hat_map.find(SDL_HAT_DOWN);
440 if (it != joy_hat_map.end())
441 controls[it->second] = jhat.value & SDL_HAT_DOWN;
444 if (changed & SDL_HAT_LEFT)
446 HatMap::iterator it = joy_hat_map.find(SDL_HAT_LEFT);
447 if (it != joy_hat_map.end())
448 controls[it->second] = jhat.value & SDL_HAT_LEFT;
451 if (changed & SDL_HAT_RIGHT)
453 HatMap::iterator it = joy_hat_map.find(SDL_HAT_RIGHT);
454 if (it != joy_hat_map.end())
455 controls[it->second] = jhat.value & SDL_HAT_RIGHT;
459 hat_state = jhat.value;
463 JoystickKeyboardController::process_key_event(const SDL_Event& event)
465 KeyMap::iterator key_mapping = keymap.find(event.key.keysym.sym);
467 // if console key was pressed: toggle console
468 if ((key_mapping != keymap.end()) && (key_mapping->second == CONSOLE)) {
469 if (event.type != SDL_KEYDOWN) return;
470 Console::instance->toggle();
474 // if console is open: send key there
475 if (Console::instance->hasFocus()) {
476 process_console_key_event(event);
480 // if menu mode: send key there
481 if (Menu::current()) {
482 process_menu_key_event(event);
486 // default action: update controls
487 if(key_mapping == keymap.end()) {
488 log_debug << "Key " << event.key.keysym.sym << " is unbound" << std::endl;
491 Control control = key_mapping->second;
492 controls[control] = (event.type == SDL_KEYDOWN);
496 JoystickKeyboardController::process_console_key_event(const SDL_Event& event)
498 if (event.type != SDL_KEYDOWN) return;
500 switch (event.key.keysym.sym) {
502 Console::instance->enter();
505 Console::instance->backspace();
508 Console::instance->autocomplete();
511 Console::instance->scroll(-1);
514 Console::instance->scroll(+1);
517 Console::instance->move_cursor(-65535);
520 Console::instance->move_cursor(+65535);
523 Console::instance->show_history(-1);
526 Console::instance->show_history(+1);
529 Console::instance->move_cursor(-1);
532 Console::instance->move_cursor(+1);
535 int c = event.key.keysym.unicode;
536 if ((c >= 32) && (c <= 126)) {
537 Console::instance->input((char)c);
544 JoystickKeyboardController::process_menu_key_event(const SDL_Event& event)
546 // wait for key mode?
547 if(wait_for_key >= 0) {
548 if(event.type == SDL_KEYUP)
551 if(event.key.keysym.sym != SDLK_ESCAPE
552 && event.key.keysym.sym != SDLK_PAUSE) {
553 reset_key(event.key.keysym.sym, (Control) wait_for_key);
556 key_options_menu->update();
560 if(wait_for_joystick >= 0) {
561 if(event.key.keysym.sym == SDLK_ESCAPE) {
563 joystick_options_menu->update();
564 wait_for_joystick = -1;
570 /* we use default keys when the menu is open (to avoid problems when
571 * redefining keys to invalid settings
573 switch(event.key.keysym.sym) {
589 control = MENU_SELECT;
593 control = PAUSE_MENU;
600 controls[control] = (event.type == SDL_KEYDOWN);
604 JoystickKeyboardController::unbind_control(Control control)
606 // remove all previous mappings for that control
607 for(AxisMap::iterator i = joy_axis_map.begin();
608 i != joy_axis_map.end(); /* no ++i */) {
609 if(i->second == control) {
610 AxisMap::iterator e = i;
612 joy_axis_map.erase(e);
618 for(ButtonMap::iterator i = joy_button_map.begin();
619 i != joy_button_map.end(); /* no ++i */) {
620 if(i->second == control) {
621 ButtonMap::iterator e = i;
623 joy_button_map.erase(e);
629 for(HatMap::iterator i = joy_hat_map.begin();
630 i != joy_hat_map.end(); /* no ++i */) {
631 if(i->second == control) {
632 HatMap::iterator e = i;
634 joy_hat_map.erase(e);
642 JoystickKeyboardController::reset_joyaxis(int axis, Control control)
644 // axis isn't the SDL axis number, but axisnumber + 1 with sign
645 // changed depending on if the positive or negative end is to be
646 // used (negative axis 0 becomes -1, positive axis 2 becomes +3,
649 unbind_control(control);
651 // remove all previous and for that axis
652 AxisMap::iterator i = joy_axis_map.find(axis);
653 if(i != joy_axis_map.end())
654 joy_axis_map.erase(i);
657 joy_axis_map.insert(std::make_pair(axis, control));
661 JoystickKeyboardController::reset_joyhat(int dir, Control c)
664 joy_hat_map.insert(std::make_pair(dir, c));
668 JoystickKeyboardController::reset_joybutton(int button, Control control)
670 unbind_control(control);
673 joy_button_map.insert(std::make_pair(button, control));
675 // map all unused buttons to MENU_SELECT
676 for(int b = 0; b < max_joybuttons; ++b) {
677 ButtonMap::iterator i = joy_button_map.find(b);
678 if(i != joy_button_map.end())
681 joy_button_map.insert(std::make_pair(b, MENU_SELECT));
686 JoystickKeyboardController::reset_key(SDLKey key, Control control)
688 // remove all previous mappings for that control and for that key
689 for(KeyMap::iterator i = keymap.begin();
690 i != keymap.end(); /* no ++i */) {
691 if(i->second == control) {
692 KeyMap::iterator e = i;
699 KeyMap::iterator i = keymap.find(key);
700 if(i != keymap.end())
704 keymap.insert(std::make_pair(key, control));
708 JoystickKeyboardController::reversemap_key(Control c)
710 for(KeyMap::iterator i = keymap.begin(); i != keymap.end(); ++i) {
719 JoystickKeyboardController::reversemap_joyaxis(Control c)
721 for(AxisMap::iterator i = joy_axis_map.begin(); i != joy_axis_map.end(); ++i) {
730 JoystickKeyboardController::reversemap_joybutton(Control c)
732 for(ButtonMap::iterator i = joy_button_map.begin();
733 i != joy_button_map.end(); ++i) {
742 JoystickKeyboardController::reversemap_joyhat(Control c)
744 for(HatMap::iterator i = joy_hat_map.begin();
745 i != joy_hat_map.end(); ++i) {
754 JoystickKeyboardController::get_key_options_menu()
756 if(key_options_menu == 0) {
757 key_options_menu = new KeyboardMenu(this);
760 return key_options_menu;
764 JoystickKeyboardController::get_joystick_options_menu()
766 if(joystick_options_menu == 0) {
767 joystick_options_menu = new JoystickMenu(this);
770 return joystick_options_menu;
773 //----------------------------------------------------------------------------
775 JoystickKeyboardController::KeyboardMenu::KeyboardMenu(
776 JoystickKeyboardController* _controller)
777 : controller(_controller)
779 add_label(_("Setup Keyboard"));
781 add_controlfield(Controller::UP, _("Up"));
782 add_controlfield(Controller::DOWN, _("Down"));
783 add_controlfield(Controller::LEFT, _("Left"));
784 add_controlfield(Controller::RIGHT, _("Right"));
785 add_controlfield(Controller::JUMP, _("Jump"));
786 add_controlfield(Controller::ACTION, _("Action"));
787 add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
788 add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
789 if (config->console_enabled) {
790 add_controlfield(Controller::CONSOLE, _("Console"));
797 JoystickKeyboardController::KeyboardMenu::~KeyboardMenu()
801 JoystickKeyboardController::KeyboardMenu::get_key_name(SDLKey key)
807 return _("Up cursor");
809 return _("Down cursor");
811 return _("Left cursor");
813 return _("Right cursor");
819 return _("Right Shift");
821 return _("Left Shift");
823 return _("Right Control");
825 return _("Left Control");
827 return _("Right Alt");
829 return _("Left Alt");
831 return SDL_GetKeyName((SDLKey) key);
836 JoystickKeyboardController::KeyboardMenu::menu_action(MenuItem* item)
838 assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
839 item->change_input(_("Press Key"));
840 controller->wait_for_key = item->id;
844 JoystickKeyboardController::KeyboardMenu::update()
847 get_item_by_id((int) Controller::UP).change_input(get_key_name(
848 controller->reversemap_key(Controller::UP)));
849 get_item_by_id((int) Controller::DOWN).change_input(get_key_name(
850 controller->reversemap_key(Controller::DOWN)));
851 get_item_by_id((int) Controller::LEFT).change_input(get_key_name(
852 controller->reversemap_key(Controller::LEFT)));
853 get_item_by_id((int) Controller::RIGHT).change_input(get_key_name(
854 controller->reversemap_key(Controller::RIGHT)));
855 get_item_by_id((int) Controller::JUMP).change_input(get_key_name(
856 controller->reversemap_key(Controller::JUMP)));
857 get_item_by_id((int) Controller::ACTION).change_input(get_key_name(
858 controller->reversemap_key(Controller::ACTION)));
859 get_item_by_id((int) Controller::PEEK_LEFT).change_input(get_key_name(
860 controller->reversemap_key(Controller::PEEK_LEFT)));
861 get_item_by_id((int) Controller::PEEK_RIGHT).change_input(get_key_name(
862 controller->reversemap_key(Controller::PEEK_RIGHT)));
863 if (config->console_enabled) {
864 get_item_by_id((int) Controller::CONSOLE).change_input(get_key_name(
865 controller->reversemap_key(Controller::CONSOLE)));
869 //---------------------------------------------------------------------------
871 JoystickKeyboardController::JoystickMenu::JoystickMenu(
872 JoystickKeyboardController* _controller)
873 : controller(_controller)
875 add_label(_("Setup Joystick"));
877 if(controller->joysticks.size() > 0) {
878 add_controlfield(Controller::UP, _("Up"));
879 add_controlfield(Controller::DOWN, _("Down"));
880 add_controlfield(Controller::LEFT, _("Left"));
881 add_controlfield(Controller::RIGHT, _("Right"));
882 add_controlfield(Controller::JUMP, _("Jump"));
883 add_controlfield(Controller::ACTION, _("Action"));
884 add_controlfield(Controller::PAUSE_MENU, _("Pause/Menu"));
885 add_controlfield(Controller::PEEK_LEFT, _("Peek Left"));
886 add_controlfield(Controller::PEEK_RIGHT, _("Peek Right"));
888 add_deactive(-1, _("No Joysticks found"));
895 JoystickKeyboardController::JoystickMenu::~JoystickMenu()
899 JoystickKeyboardController::JoystickMenu::get_button_name(int button)
904 std::ostringstream name;
905 name << "Button " << button;
910 JoystickKeyboardController::JoystickMenu::menu_action(MenuItem* item)
912 assert(item->id >= 0 && item->id < Controller::CONTROLCOUNT);
913 item->change_input(_("Press Button"));
914 controller->wait_for_joystick = item->id;
918 JoystickKeyboardController::JoystickMenu::update_menu_item(Control id)
920 int button = controller->reversemap_joybutton(id);
921 int axis = controller->reversemap_joyaxis(id);
922 int hat_dir = controller->reversemap_joyhat(id);
925 get_item_by_id((int)id).change_input(get_button_name(button));
926 } else if (axis != 0) {
927 std::ostringstream name;
938 else if (abs(axis) == 2)
940 else if (abs(axis) == 2)
942 else if (abs(axis) == 3)
947 get_item_by_id((int)id).change_input(name.str());
948 } else if (hat_dir != -1) {
970 name = "Unknown hat_dir";
974 get_item_by_id((int)id).change_input(name);
976 get_item_by_id((int)id).change_input("None");
981 JoystickKeyboardController::JoystickMenu::update()
983 if(controller->joysticks.size() == 0)
986 update_menu_item(Controller::UP);
987 update_menu_item(Controller::DOWN);
988 update_menu_item(Controller::LEFT);
989 update_menu_item(Controller::RIGHT);
991 update_menu_item(Controller::JUMP);
992 update_menu_item(Controller::ACTION);
993 update_menu_item(Controller::PAUSE_MENU);
994 update_menu_item(Controller::PEEK_LEFT);
995 update_menu_item(Controller::PEEK_RIGHT);