void SSButtonInput::UpdateUserLayer( const float deltaTime ) { if( m_TimeOutCountDown > 0.0f ) m_TimeOutCountDown -= deltaTime; else { for( ButtonKeyBinding& child : m_CurrentLevel->Children ) { if( child.Button ) child.Button->SetSecondaryText( "" ); } m_CurrentLevel = &m_RootLevel; for( ButtonKeyBinding& child : m_CurrentLevel->Children ) { if( child.Button && child.Button->IsEnabled() ) child.Button->SetSecondaryText( SDL_GetScancodeName( g_SSKeyBinding.GetPrimaryScancodeFromAction( child.Action ) ) ); } } if( m_CurrentLevel != &m_RootLevel ) { for( ButtonKeyBinding& child : m_RootLevel.Children ) { if ( child.Button && child.Button->IsEnabled( ) && child.Children.size( ) == 0 ) child.Button->SetSecondaryText( SDL_GetScancodeName( g_SSKeyBinding.GetPrimaryScancodeFromAction( child.Action ) ) ); } } }
/** * @brief SDL_GetScancodeName negative cases * * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeName */ int keyboard_getScancodeNameNegative(void *arg) { SDL_Scancode scancode; char *result; char *expected = ""; /* Clear error message */ SDL_ClearError(); SDLTest_AssertPass("Call to SDL_ClearError()"); /* Negative scancode */ scancode = (SDL_Scancode)SDLTest_RandomIntegerInRange(LONG_MIN, -1); result = (char *)SDL_GetScancodeName(scancode); SDLTest_AssertPass("Call to SDL_GetScancodeName(%d/negative)", scancode); SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL"); SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result); _checkInvalidScancodeError(); /* Large scancode */ scancode = (SDL_Scancode)SDLTest_RandomIntegerInRange(SDL_NUM_SCANCODES, LONG_MAX); result = (char *)SDL_GetScancodeName(scancode); SDLTest_AssertPass("Call to SDL_GetScancodeName(%d/large)", scancode); SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL"); SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result); _checkInvalidScancodeError(); return TEST_COMPLETED; }
static void PrintKey(SDL_Keysym * sym, SDL_bool pressed, SDL_bool repeat) { char message[512]; char *spot; size_t left; spot = message; left = sizeof(message); /* Print the keycode, name and state */ if (sym->sym) { print_string(&spot, &left, "Key %s: scancode %d = %s, keycode 0x%08X = %s ", pressed ? "pressed " : "released", sym->scancode, SDL_GetScancodeName(sym->scancode), sym->sym, SDL_GetKeyName(sym->sym)); } else { print_string(&spot, &left, "Unknown Key (scancode %d = %s) %s ", sym->scancode, SDL_GetScancodeName(sym->scancode), pressed ? "pressed " : "released"); } print_modifiers(&spot, &left); if (repeat) { print_string(&spot, &left, " (repeat)"); } SDL_Log("%s\n", message); }
static void PrintKey(SDL_Keysym * sym, SDL_bool pressed, SDL_bool repeat) { char message[512]; char *spot; size_t left; spot = message; left = sizeof(message); /* Print the keycode, name and state */ if (sym->sym) { print_string(&spot, &left, "Key %s: scancode %d = %s, keycode 0x%08X = %s ", pressed ? "pressed " : "released", sym->scancode, SDL_GetScancodeName(sym->scancode), sym->sym, SDL_GetKeyName(sym->sym)); } else { print_string(&spot, &left, "Unknown Key (scancode %d = %s) %s ", sym->scancode, SDL_GetScancodeName(sym->scancode), pressed ? "pressed" : "released"); } /* Print the translated character, if one exists */ if (sym->unicode) { /* Is it a control-character? */ if (sym->unicode < ' ') { print_string(&spot, &left, " (^%c)", sym->unicode + '@'); } else { #ifdef UNICODE print_string(&spot, &left, " (%c)", sym->unicode); #else /* This is a Latin-1 program, so only show 8-bits */ if (!(sym->unicode & 0xFF00)) print_string(&spot, &left, " (%c)", sym->unicode); else print_string(&spot, &left, " (0x%X)", sym->unicode); #endif } } print_modifiers(&spot, &left); if (repeat) { print_string(&spot, &left, " (repeat)"); } SDL_Log("%s", message); }
void PGE_KeyGrabMenuItem::render(int x, int y) { PGE_Menuitem::render(x, y); float colorLevel = m_enabled ? 1.0 : 0.5; if(chosing) FontManager::printText(QString("..."), x+valueOffset, y, _font_id, colorLevel, colorLevel, colorLevel); else if(targetKey) { if(joystick_mode) { if(targetKey->type !=-1 ) FontManager::printText(QString("Key=%1 ID=%2 Type=%3") .arg(targetKey->val) .arg(targetKey->id) .arg(targetKey->type) , x+valueOffset, y, _font_id, colorLevel, colorLevel, colorLevel); else FontManager::printText(QString("<none>"), x+valueOffset, y, _font_id, colorLevel, colorLevel, colorLevel); } else { if(targetKey->val!=-1) FontManager::printText(QString(SDL_GetScancodeName((SDL_Scancode)targetKey->val)), x+valueOffset, y, _font_id, colorLevel, colorLevel, colorLevel); else FontManager::printText(QString("<none>"), x+valueOffset, y, _font_id, colorLevel, colorLevel, colorLevel); } } }
void KeyConfigMenu::render() const { int x = 0; int y = 0; for (unsigned i = 0; i < _items.size(); ++i) { y += 18; std::string text = _items.at(i).getName(); if (_selection == i && (SDL_GetTicks() - _time) % 1000 < 500) { text = "\u25b6" + text; } else { text = " " + text; } _SDLContext.renderText(text, { 0, 0, 0 }, _SDLContext._fontPs, x, y); if (i != _items.size() - 1 && !(_waitingForKey && _selection == i)) { const char* name; if (_items.at(i).getValue() != 0) { name = SDL_GetScancodeName( (SDL_Scancode) _items.at(i).getValue()); } else { name = "--"; } _SDLContext.renderText(name, { 0, 0, 0 }, _SDLContext._fontPs, x + 350, y); } else if (_selection == i && _waitingForKey && (SDL_GetTicks() - _time) % 1000 < 500) { _SDLContext.renderText("--press key--", { 0, 0, 0 }, _SDLContext._fontPs, x + 350, y); } } }
static int a_key(int index, int subindex) { static int k; char text[16]; if (index == M_INIT) { k = 0; // First key to enter now. pointer_enabled = 0; keys_enabled = 1; backoff = controlmenu; return 0; } if (k < 5 && subindex != SDL_SCANCODE_ESCAPE) { strncpy(text, SDL_GetScancodeName((SDL_Scancode)subindex), 15); tiny->vanilla(MENUX+80, MENUY+nowmenu[k+2].y, text, 12); settings.key[k] = subindex; if (k == 4) { tiny->vanilla_c(MENUX+(MENUXS+BORDER)/2, MENUY+140, "Press any key to continue", 12); } } if (k==5) { setkeys(settings.key[0], settings.key[1], settings.key[2], settings.key[3], settings.key[4]); buildmenu(controlmenu); } k++; return 0; }
static mrb_value mrb_sdl2_keyboard_scancode_name(mrb_state *mrb, mrb_value mod) { mrb_int code; mrb_get_args(mrb, "i", &code); return mrb_str_new_cstr(mrb, SDL_GetScancodeName((SDL_Scancode)code)); }
void Config::parseLine(const uint32_t lineno, const std::string& line) { std::istringstream ss(line); std::string cmd; std::stringstream errPrelude; errPrelude << "[At line " << lineno << "] "; auto startsWith = [] (const std::string& str, const std::string& substr) -> bool { return strncmp(str.c_str(), substr.c_str(), substr.length()) == 0; }; ss >> cmd; if (startsWith(cmd, "button.")) { auto key = cmd.substr(7); auto it = nameToButton.find(key); if (it == nameToButton.end()) { std::cerr << errPrelude.str() << "Unknown button: " << key << std::endl; } else { std::string name; ss >> name; // eat '=' ss >> name; keybindings[it->second] = SDL_GetScancodeFromName(name.c_str()); std::clog << "[INFO] Bound " << it->first << " to " << SDL_GetScancodeName(keybindings[it->second]) << "\r\n"; } }
/* =============== IN_PrintKey =============== */ static void IN_PrintKey( const SDL_Keysym *keysym, keyNum_t key, qboolean down ) { if( down ) Com_Printf( "+ " ); else Com_Printf( " " ); Com_Printf( "Scancode: 0x%02x(%s) Sym: 0x%02x(%s)", keysym->scancode, SDL_GetScancodeName( keysym->scancode ), keysym->sym, SDL_GetKeyName( keysym->sym ) ); if( keysym->mod & KMOD_LSHIFT ) Com_Printf( " KMOD_LSHIFT" ); if( keysym->mod & KMOD_RSHIFT ) Com_Printf( " KMOD_RSHIFT" ); if( keysym->mod & KMOD_LCTRL ) Com_Printf( " KMOD_LCTRL" ); if( keysym->mod & KMOD_RCTRL ) Com_Printf( " KMOD_RCTRL" ); if( keysym->mod & KMOD_LALT ) Com_Printf( " KMOD_LALT" ); if( keysym->mod & KMOD_RALT ) Com_Printf( " KMOD_RALT" ); if( keysym->mod & KMOD_LGUI ) Com_Printf( " KMOD_LGUI" ); if( keysym->mod & KMOD_RGUI ) Com_Printf( " KMOD_RGUI" ); if( keysym->mod & KMOD_NUM ) Com_Printf( " KMOD_NUM" ); if( keysym->mod & KMOD_CAPS ) Com_Printf( " KMOD_CAPS" ); if( keysym->mod & KMOD_MODE ) Com_Printf( " KMOD_MODE" ); if( keysym->mod & KMOD_RESERVED ) Com_Printf( " KMOD_RESERVED" ); Com_Printf( " Q:0x%02x(%s)\n", key, Key_KeynumToString( key, qtrue ) ); }
void Input::updateEvent() { mouseXRel_ = 0; mouseYRel_ = 0; while(SDL_PollEvent(&event_)) { switch(event_.type) { case SDL_KEYDOWN: keyboardKeys_[event_.key.keysym.scancode] = KEY::DOWN; break; case SDL_KEYUP: keyboardKeys_[event_.key.keysym.scancode] = KEY::UP; break; case SDL_MOUSEBUTTONDOWN: mouseKeys_[event_.button.button] = KEY::DOWN; break; case SDL_MOUSEBUTTONUP: mouseKeys_[event_.button.button] = KEY::UP; break; case SDL_MOUSEMOTION: mouseX_ = event_.motion.x; mouseY_ = event_.motion.y; mouseXRel_ = event_.motion.xrel; mouseYRel_ = event_.motion.yrel; break; case SDL_WINDOWEVENT: switch(event_.window.event) { case SDL_WINDOWEVENT_CLOSE: isOver_ = true; break; case SDL_WINDOWEVENT_RESIZED: int width = event_.window.data1; int height = event_.window.data2; Utils::resizeWindow(width, height); scene_->setWindowWidth(width); scene_->setWindowHeight(height); } break; default: break; } if(LOG_ENABLED) LOG("The key " + std::string(SDL_GetScancodeName(event_.key.keysym.scancode)) + " was pressed", std::cout); } }
char* JOY_GetKeyName(int keycode) { #ifdef OPENDINGUX return OPENDINGUX_GetKeyName(keycode); #elif ANDROID || DARWIN || SDL2 return (char*)SDL_GetScancodeName(keycode); #else return (char*)SDL_GetKeyName(keycode); #endif }
std::string SDLKeyboard::getButtonName(unsigned int button) const { const char *keyname = SDL_GetScancodeName((SDL_scancode)button); if (keyname) { return keyname; } else { std::ostringstream ostr; ostr << '#' << button; return ostr.str(); } }
int main( int argc, char* argv[] ) { RegisterLogger( ); Logger::IWantItAll( ); SDL_Init( SDL_INIT_EVERYTHING ); SDL_CreateWindow( "Input test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 200, 200, SDL_WINDOW_SHOWN ); g_TextInput.Initialize( ); g_Input->Initialize( ); ActionIdentifier testAction = g_KeyBindings.AddAction( "testaction", SDL_SCANCODE_W, "test desc", SDL_CONTROLLER_BUTTON_B ); ActionIdentifier testAction2 = g_KeyBindings.AddAction( "testaction2", SDL_SCANCODE_S, "test desc", SDL_CONTROLLER_BUTTON_A ); g_KeyBindings.ReadConfig( ); bool quit = false; while ( !quit ) { SDL_Event event; g_Input->Update( ); while ( SDL_PollEvent( &event ) > 0 ) { g_TextInput.HandleEvents( event ); g_Input->HandleEvent( event ); switch ( event.type ) { case SDL_KEYDOWN: if ( event.key.keysym.scancode == SDL_SCANCODE_ESCAPE ) { quit = true; } break; } } while ( g_Input->GetEditablePressStack( ).size( ) > 0 ) { std::cout << SDL_GetScancodeName( g_Input->GetEditablePressStack( ).back( ) ) << std::endl; g_Input->GetEditablePressStack( ).pop_back( ); } if ( g_KeyBindings.ActionUpDown( testAction, INPUT_TYPE_ANY ) ) { std::cout << "action1 up down with any" << std::endl; } if ( g_KeyBindings.ActionDownUp( testAction2, INPUT_TYPE_GAMEPAD_FIRST ) ) { std::cout << "action2 down up with gamepad only" << std::endl; } std::this_thread::sleep_for (std::chrono::milliseconds(17)); } g_ConfigManager.SaveDirty( ); SDL_Quit( ); return 0; }
void SDL2InputBackend::onEvent(const SDL_Event & event) { switch(event.type) { case SDL_WINDOWEVENT: { if(event.window.event == SDL_WINDOWEVENT_ENTER) { cursorInWindow = true; } else if(event.window.event == SDL_WINDOWEVENT_LEAVE) { cursorInWindow = false; } break; } case SDL_KEYDOWN: case SDL_KEYUP: { SDL_Scancode key = event.key.keysym.scancode; if(key >= 0 && size_t(key) < ARRAY_SIZE(sdlToArxKey) && sdlToArxKey[key] >= 0) { keyStates[sdlToArxKey[key] - Keyboard::KeyBase] = (event.key.state == SDL_PRESSED); } else { LogWarning << "Unmapped SDL key: " << (int)key << " = " << SDL_GetScancodeName(key); } break; } case SDL_MOUSEMOTION: { cursorAbs = Vec2i(event.motion.x, event.motion.y); cursorRelAccum += Vec2i(event.motion.xrel, event.motion.yrel); cursorInWindow = true; break; } case SDL_MOUSEWHEEL: { wheel += event.wheel.y; } case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { Uint8 button = event.button.button; if(button < ARRAY_SIZE(sdlToArxButton) && sdlToArxButton[button] >= 0) { size_t i = sdlToArxButton[button] - Mouse::ButtonBase; if((event.button.state == SDL_PRESSED)) { buttonStates[i] = true, clickCount[i]++; } else { buttonStates[i] = false, unclickCount[i]++; } } else if(button != 0) { LogWarning << "Unmapped SDL mouse button: " << (int)button; } break; } } }
static void IN_DebugKeyEvent(SDL_Event *event) { const char *eventtype = (event->key.state == SDL_PRESSED) ? "SDL_KEYDOWN" : "SDL_KEYUP"; Con_Printf ("%s scancode: '%s' keycode: '%s' time: %g\n", eventtype, SDL_GetScancodeName(event->key.keysym.scancode), SDL_GetKeyName(event->key.keysym.sym), Sys_DoubleTime()); }
static void PrintKey(SDL_keysym * sym, SDL_bool pressed, SDL_bool repeat) { /* Print the keycode, name and state */ if (sym->sym) { printf("Key %s: scancode %d = %s, keycode 0x%08X = %s ", pressed ? "pressed " : "released", sym->scancode, SDL_GetScancodeName(sym->scancode), sym->sym, SDL_GetKeyName(sym->sym)); } else { printf("Unknown Key (scancode %d = %s) %s ", sym->scancode, SDL_GetScancodeName(sym->scancode), pressed ? "pressed" : "released"); } /* Print the translated character, if one exists */ if (sym->unicode) { /* Is it a control-character? */ if (sym->unicode < ' ') { printf(" (^%c)", sym->unicode + '@'); } else { #ifdef UNICODE printf(" (%c)", sym->unicode); #else /* This is a Latin-1 program, so only show 8-bits */ if (!(sym->unicode & 0xFF00)) printf(" (%c)", sym->unicode); else printf(" (0x%X)", sym->unicode); #endif } } print_modifiers(); if (repeat) { printf(" (repeat)"); } printf("\n"); }
void keyboard_shortcut_format_string(char *buffer, uint16 shortcutKey) { char formatBuffer[256]; *buffer = 0; if (shortcutKey == 0xFFFF) return; if (shortcutKey & 0x100) { format_string(formatBuffer, STR_SHIFT_PLUS, NULL); strcat(buffer, formatBuffer); } if (shortcutKey & 0x200) { format_string(formatBuffer, STR_CTRL_PLUS, NULL); strcat(buffer, formatBuffer); } if (shortcutKey & 0x400) { format_string(formatBuffer, STR_ALT_PLUS, NULL); strcat(buffer, formatBuffer); } strcat(buffer, SDL_GetScancodeName(shortcutKey & 0xFF)); }
void initControlsDisplay(void) { int i; for (i = 0 ; i < CONTROL_MAX ; i++) { strcpy(controlWidget[i]->options[0], ""); strcpy(controlWidget[i]->options[1], ""); if (app.keyControls[i] != 0) { sprintf(controlWidget[i]->options[0], "%s", SDL_GetScancodeName(app.keyControls[i])); } if (app.mouseControls[i] != 0) { sprintf(controlWidget[i]->options[1], "Btn %d", app.mouseControls[i]); } } getWidget("restore", "controls")->action = restoreDefaults; }
bool KeyBindingCollection::AddMappingWithScancode( SDL_Scancode scancode, ActionIdentifier action, KeyBindingType keyBindType, bool overwrite, bool clearConflicting, rString* errorString ) { FillTheVoid( action ); auto keyIt = m_ScancodeToAction.find( scancode ); // Warn about overwriting duplicate keybindings if ( keyIt != m_ScancodeToAction.end() && !clearConflicting ) { LogInput( "Can't bind key: \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action " + g_KeyBindings.GetDescription( action ) + " because it is already bound to action \"" + g_KeyBindings.GetDescription( keyIt->second ) + "\"", "KeyBindings", LogSeverity::WARNING_MSG ); if ( errorString != nullptr ) { *errorString = "Can't bind key: \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action " + g_KeyBindings.GetDescription( action ) + " because it is already bound to action \"" + g_KeyBindings.GetDescription( keyIt->second ) + "\""; } return false; } else { // Try to key to action if ( BindAction( action, scancode, keyBindType, overwrite ) ) { LogInput( "Bound key \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action \"" + g_KeyBindings.GetDescription( action ) + "\"", "KeyBindings", LogSeverity::DEBUG_MSG ); if ( errorString != nullptr ) { *errorString = "Bound key \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action \"" + g_KeyBindings.GetDescription( action ) + "\""; } return true; } else { LogInput( "Can't bind key: \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action \"" + g_KeyBindings.GetDescription( action ) + "\" because no free bind slots are avaliable", "KeyBindings", LogSeverity::WARNING_MSG ); if ( errorString != nullptr ) { *errorString = "Can't bind key: \"" + rString( SDL_GetScancodeName( scancode ) ) + "\" to action \"" + g_KeyBindings.GetDescription( action ) + "\" because no free bind slots are avaliable"; } return false; } } }
void LuaSystem::onMessage(jl::Message *message) { if(message->name == "ReloadLua") { for(auto itr = getEntities().begin(); itr != getEntities().end(); itr++) { LuaComponent *luaComp = itr->second->getComponent<LuaComponent>(); runScript(*itr->second); } } else { // Find entities (scripts) associated with this message auto itr = m_subscribedScripts.find(message->name); if(itr != m_subscribedScripts.end()) { for(std::size_t i = 0; i < itr->second.size(); i++) { lua_State *state = m_luaEnv.getRaw(); // Grab event function lua_getglobal(state, "events"); int eventFuncIndex = lua_gettop(state); // Push self LuaEnvironment::pushObjectToLua<Entity>(state, itr->second[i], "jl.Entity"); // Push event name lua_pushstring(state, message->name.c_str()); int argCount = 2; // Push event args, depending on event if(message->name == "KeyDown" || message->name == "KeyUp") { if(message->isType<SDL_Event>()) { const SDL_Event& sdlEvent = static_cast<MessageData<SDL_Event>*>(message)->data; argCount += m_luaEnv.pushArgsToLua( LuaArg<std::string>{SDL_GetScancodeName(sdlEvent.key.keysym.scancode)}, LuaArg<bool>{sdlEvent.key.repeat}); } } else if(message->isType<std::string>()) { std::string strData = static_cast<MessageData<std::string>*>(message)->data; lua_pushstring(state, strData.c_str()); ++argCount; } // Call event function if(!lua_isnil(state, eventFuncIndex)) if(lua_pcall(state, argCount, 0, 0)) m_luaEnv.reportError(); } } } }
static void PrintEvent(SDL_Event * event) { fprintf(stderr, "SDL EVENT: "); switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_SHOWN: fprintf(stderr, "Window %d shown", event->window.windowID); break; case SDL_WINDOWEVENT_HIDDEN: fprintf(stderr, "Window %d hidden", event->window.windowID); break; case SDL_WINDOWEVENT_EXPOSED: fprintf(stderr, "Window %d exposed", event->window.windowID); break; case SDL_WINDOWEVENT_MOVED: fprintf(stderr, "Window %d moved to %d,%d", event->window.windowID, event->window.data1, event->window.data2); break; case SDL_WINDOWEVENT_RESIZED: fprintf(stderr, "Window %d resized to %dx%d", event->window.windowID, event->window.data1, event->window.data2); break; case SDL_WINDOWEVENT_MINIMIZED: fprintf(stderr, "Window %d minimized", event->window.windowID); break; case SDL_WINDOWEVENT_MAXIMIZED: fprintf(stderr, "Window %d maximized", event->window.windowID); break; case SDL_WINDOWEVENT_RESTORED: fprintf(stderr, "Window %d restored", event->window.windowID); break; case SDL_WINDOWEVENT_ENTER: fprintf(stderr, "Mouse entered window %d", event->window.windowID); break; case SDL_WINDOWEVENT_LEAVE: fprintf(stderr, "Mouse left window %d", event->window.windowID); break; case SDL_WINDOWEVENT_FOCUS_GAINED: fprintf(stderr, "Window %d gained keyboard focus", event->window.windowID); break; case SDL_WINDOWEVENT_FOCUS_LOST: fprintf(stderr, "Window %d lost keyboard focus", event->window.windowID); break; case SDL_WINDOWEVENT_CLOSE: fprintf(stderr, "Window %d closed", event->window.windowID); break; default: fprintf(stderr, "Window %d got unknown event %d", event->window.windowID, event->window.event); break; } break; case SDL_KEYDOWN: fprintf(stderr, "Keyboard %d: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", event->key.which, event->key.windowID, event->key.keysym.scancode, SDL_GetScancodeName(event->key.keysym.scancode), event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); break; case SDL_KEYUP: fprintf(stderr, "Keyboard %d: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", event->key.which, event->key.windowID, event->key.keysym.scancode, SDL_GetScancodeName(event->key.keysym.scancode), event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); break; case SDL_TEXTINPUT: fprintf(stderr, "Keyboard %d: text input \"%s\" in window %d", event->text.which, event->text.text, event->text.windowID); break; case SDL_MOUSEMOTION: fprintf(stderr, "Mouse %d: moved to %d,%d (%d,%d) in window %d", event->motion.which, event->motion.x, event->motion.y, event->motion.xrel, event->motion.yrel, event->motion.windowID); break; case SDL_MOUSEBUTTONDOWN: fprintf(stderr, "Mouse %d: button %d pressed at %d,%d in window %d", event->button.which, event->button.button, event->button.x, event->button.y, event->button.windowID); break; case SDL_MOUSEBUTTONUP: fprintf(stderr, "Mouse %d: button %d released at %d,%d in window %d", event->button.which, event->button.button, event->button.x, event->button.y, event->button.windowID); break; case SDL_MOUSEWHEEL: fprintf(stderr, "Mouse %d: wheel scrolled %d in x and %d in y in window %d", event->wheel.which, event->wheel.x, event->wheel.y, event->wheel.windowID); break; case SDL_JOYBALLMOTION: fprintf(stderr, "Joystick %d: ball %d moved by %d,%d", event->jball.which, event->jball.ball, event->jball.xrel, event->jball.yrel); break; case SDL_JOYHATMOTION: fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which, event->jhat.hat); switch (event->jhat.value) { case SDL_HAT_CENTERED: fprintf(stderr, "CENTER"); break; case SDL_HAT_UP: fprintf(stderr, "UP"); break; case SDL_HAT_RIGHTUP: fprintf(stderr, "RIGHTUP"); break; case SDL_HAT_RIGHT: fprintf(stderr, "RIGHT"); break; case SDL_HAT_RIGHTDOWN: fprintf(stderr, "RIGHTDOWN"); break; case SDL_HAT_DOWN: fprintf(stderr, "DOWN"); break; case SDL_HAT_LEFTDOWN: fprintf(stderr, "LEFTDOWN"); break; case SDL_HAT_LEFT: fprintf(stderr, "LEFT"); break; case SDL_HAT_LEFTUP: fprintf(stderr, "LEFTUP"); break; default: fprintf(stderr, "UNKNOWN"); break; } break; case SDL_JOYBUTTONDOWN: fprintf(stderr, "Joystick %d: button %d pressed", event->jbutton.which, event->jbutton.button); break; case SDL_JOYBUTTONUP: fprintf(stderr, "Joystick %d: button %d released", event->jbutton.which, event->jbutton.button); break; case SDL_QUIT: fprintf(stderr, "Quit requested"); break; case SDL_USEREVENT: fprintf(stderr, "User event %d", event->user.code); break; default: fprintf(stderr, "Unknown event %d", event->type); break; } fprintf(stderr, "\n"); }
static void SDLTest_PrintEvent(SDL_Event * event) { if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) { /* Mouse and finger motion are really spammy */ return; } fprintf(stderr, "SDL EVENT: "); switch (event->type) { case SDL_WINDOWEVENT: switch (event->window.event) { case SDL_WINDOWEVENT_SHOWN: fprintf(stderr, "Window %d shown", event->window.windowID); break; case SDL_WINDOWEVENT_HIDDEN: fprintf(stderr, "Window %d hidden", event->window.windowID); break; case SDL_WINDOWEVENT_EXPOSED: fprintf(stderr, "Window %d exposed", event->window.windowID); break; case SDL_WINDOWEVENT_MOVED: fprintf(stderr, "Window %d moved to %d,%d", event->window.windowID, event->window.data1, event->window.data2); break; case SDL_WINDOWEVENT_RESIZED: fprintf(stderr, "Window %d resized to %dx%d", event->window.windowID, event->window.data1, event->window.data2); break; case SDL_WINDOWEVENT_SIZE_CHANGED: fprintf(stderr, "Window %d changed size to %dx%d", event->window.windowID, event->window.data1, event->window.data2); break; case SDL_WINDOWEVENT_MINIMIZED: fprintf(stderr, "Window %d minimized", event->window.windowID); break; case SDL_WINDOWEVENT_MAXIMIZED: fprintf(stderr, "Window %d maximized", event->window.windowID); break; case SDL_WINDOWEVENT_RESTORED: fprintf(stderr, "Window %d restored", event->window.windowID); break; case SDL_WINDOWEVENT_ENTER: fprintf(stderr, "Mouse entered window %d", event->window.windowID); break; case SDL_WINDOWEVENT_LEAVE: fprintf(stderr, "Mouse left window %d", event->window.windowID); break; case SDL_WINDOWEVENT_FOCUS_GAINED: fprintf(stderr, "Window %d gained keyboard focus", event->window.windowID); break; case SDL_WINDOWEVENT_FOCUS_LOST: fprintf(stderr, "Window %d lost keyboard focus", event->window.windowID); break; case SDL_WINDOWEVENT_CLOSE: fprintf(stderr, "Window %d closed", event->window.windowID); break; default: fprintf(stderr, "Window %d got unknown event %d", event->window.windowID, event->window.event); break; } break; case SDL_KEYDOWN: fprintf(stderr, "Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", event->key.windowID, event->key.keysym.scancode, SDL_GetScancodeName(event->key.keysym.scancode), event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); break; case SDL_KEYUP: fprintf(stderr, "Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", event->key.windowID, event->key.keysym.scancode, SDL_GetScancodeName(event->key.keysym.scancode), event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); break; case SDL_TEXTINPUT: fprintf(stderr, "Keyboard: text input \"%s\" in window %d", event->text.text, event->text.windowID); break; case SDL_MOUSEMOTION: fprintf(stderr, "Mouse: moved to %d,%d (%d,%d) in window %d", event->motion.x, event->motion.y, event->motion.xrel, event->motion.yrel, event->motion.windowID); break; case SDL_MOUSEBUTTONDOWN: fprintf(stderr, "Mouse: button %d pressed at %d,%d in window %d", event->button.button, event->button.x, event->button.y, event->button.windowID); break; case SDL_MOUSEBUTTONUP: fprintf(stderr, "Mouse: button %d released at %d,%d in window %d", event->button.button, event->button.x, event->button.y, event->button.windowID); break; case SDL_MOUSEWHEEL: fprintf(stderr, "Mouse: wheel scrolled %d in x and %d in y in window %d", event->wheel.x, event->wheel.y, event->wheel.windowID); break; case SDL_JOYBALLMOTION: fprintf(stderr, "Joystick %d: ball %d moved by %d,%d", event->jball.which, event->jball.ball, event->jball.xrel, event->jball.yrel); break; case SDL_JOYHATMOTION: fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which, event->jhat.hat); switch (event->jhat.value) { case SDL_HAT_CENTERED: fprintf(stderr, "CENTER"); break; case SDL_HAT_UP: fprintf(stderr, "UP"); break; case SDL_HAT_RIGHTUP: fprintf(stderr, "RIGHTUP"); break; case SDL_HAT_RIGHT: fprintf(stderr, "RIGHT"); break; case SDL_HAT_RIGHTDOWN: fprintf(stderr, "RIGHTDOWN"); break; case SDL_HAT_DOWN: fprintf(stderr, "DOWN"); break; case SDL_HAT_LEFTDOWN: fprintf(stderr, "LEFTDOWN"); break; case SDL_HAT_LEFT: fprintf(stderr, "LEFT"); break; case SDL_HAT_LEFTUP: fprintf(stderr, "LEFTUP"); break; default: fprintf(stderr, "UNKNOWN"); break; } break; case SDL_JOYBUTTONDOWN: fprintf(stderr, "Joystick %d: button %d pressed", event->jbutton.which, event->jbutton.button); break; case SDL_JOYBUTTONUP: fprintf(stderr, "Joystick %d: button %d released", event->jbutton.which, event->jbutton.button); break; case SDL_CLIPBOARDUPDATE: fprintf(stderr, "Clipboard updated"); break; case SDL_FINGERDOWN: case SDL_FINGERUP: fprintf(stderr, "Finger: %s touch=%lld, finger=%lld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f", (event->type == SDL_FINGERDOWN) ? "down" : "up", (long long) event->tfinger.touchId, (long long) event->tfinger.fingerId, event->tfinger.x, event->tfinger.y, event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure); break; case SDL_QUIT: fprintf(stderr, "Quit requested"); break; case SDL_USEREVENT: fprintf(stderr, "User event %d", event->user.code); break; default: fprintf(stderr, "Unknown event %d", event->type); break; } fprintf(stderr, "\n"); }
void input_config_write() { // Write out the input configuration file FILE *fp = fopen(inputconfpath, "w"); if (fp != NULL) { fprintf(fp, "[gamepad1]\n"); fprintf(fp, "kb_u=%s\n", SDL_GetScancodeName(player[0].u)); fprintf(fp, "kb_d=%s\n", SDL_GetScancodeName(player[0].d)); fprintf(fp, "kb_l=%s\n", SDL_GetScancodeName(player[0].l)); fprintf(fp, "kb_r=%s\n", SDL_GetScancodeName(player[0].r)); fprintf(fp, "kb_select=%s\n", SDL_GetScancodeName(player[0].select)); fprintf(fp, "kb_start=%s\n", SDL_GetScancodeName(player[0].start)); fprintf(fp, "kb_a=%s\n", SDL_GetScancodeName(player[0].a)); fprintf(fp, "kb_b=%s\n", SDL_GetScancodeName(player[0].b)); fprintf(fp, "kb_ta=%s\n", SDL_GetScancodeName(player[0].ta)); fprintf(fp, "kb_tb=%s\n", SDL_GetScancodeName(player[0].tb)); fprintf(fp, "js_u=%s\n", input_translate_event(player[0].ju)); fprintf(fp, "js_d=%s\n", input_translate_event(player[0].jd)); fprintf(fp, "js_l=%s\n", input_translate_event(player[0].jl)); fprintf(fp, "js_r=%s\n", input_translate_event(player[0].jr)); fprintf(fp, "js_select=%s\n", input_translate_event(player[0].jselect)); fprintf(fp, "js_start=%s\n", input_translate_event(player[0].jstart)); fprintf(fp, "js_a=%s\n", input_translate_event(player[0].ja)); fprintf(fp, "js_b=%s\n", input_translate_event(player[0].jb)); fprintf(fp, "js_ta=%s\n", input_translate_event(player[0].jta)); fprintf(fp, "js_tb=%s\n", input_translate_event(player[0].jtb)); fprintf(fp, "\n"); // End of Section fprintf(fp, "[gamepad2]\n"); fprintf(fp, "kb_u=%s\n", SDL_GetScancodeName(player[1].u)); fprintf(fp, "kb_d=%s\n", SDL_GetScancodeName(player[1].d)); fprintf(fp, "kb_l=%s\n", SDL_GetScancodeName(player[1].l)); fprintf(fp, "kb_r=%s\n", SDL_GetScancodeName(player[1].r)); fprintf(fp, "kb_select=%s\n", SDL_GetScancodeName(player[1].select)); fprintf(fp, "kb_start=%s\n", SDL_GetScancodeName(player[1].start)); fprintf(fp, "kb_a=%s\n", SDL_GetScancodeName(player[1].a)); fprintf(fp, "kb_b=%s\n", SDL_GetScancodeName(player[1].b)); fprintf(fp, "kb_ta=%s\n", SDL_GetScancodeName(player[1].ta)); fprintf(fp, "kb_tb=%s\n", SDL_GetScancodeName(player[1].tb)); fprintf(fp, "js_u=%s\n", input_translate_event(player[1].ju)); fprintf(fp, "js_d=%s\n", input_translate_event(player[1].jd)); fprintf(fp, "js_l=%s\n", input_translate_event(player[1].jl)); fprintf(fp, "js_r=%s\n", input_translate_event(player[1].jr)); fprintf(fp, "js_select=%s\n", input_translate_event(player[1].jselect)); fprintf(fp, "js_start=%s\n", input_translate_event(player[1].jstart)); fprintf(fp, "js_a=%s\n", input_translate_event(player[1].ja)); fprintf(fp, "js_b=%s\n", input_translate_event(player[1].jb)); fprintf(fp, "js_ta=%s\n", input_translate_event(player[1].jta)); fprintf(fp, "js_tb=%s\n", input_translate_event(player[1].jtb)); fprintf(fp, "\n"); // End of Section fclose(fp); } }
void EventSystem::createMessages() { SDL_Event event; auto messenger = Messenger::getInstance(); Message* msg; while(SDL_PollEvent(&event)) { if (event.type == SDL_QUIT) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_QUIT); } else if (event.type == SDL_APP_TERMINATING) { msg = messenger->appendMessage(); std::cout << "App Terminating..." << std::endl; msg->setType(enumMessageType::EVENT_QUIT); } else if (event.type == SDL_APP_LOWMEMORY) { msg = messenger->appendMessage(); std::cerr << "Low Memory: Calling Event Quit" << std::endl; msg->setType(enumMessageType::EVENT_QUIT); } else if (event.type == SDL_APP_WILLENTERBACKGROUND) { } else if (event.type == SDL_APP_DIDENTERBACKGROUND) { } else if (event.type == SDL_APP_WILLENTERFOREGROUND) { } else if (event.type == SDL_APP_DIDENTERFOREGROUND) { } else if (event.type == SDL_WINDOWEVENT) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_WINDOW); } else if (event.type == SDL_SYSWMEVENT) { } else if (event.type == SDL_KEYDOWN) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_KEYBOARD); //The key code stringType keyCodeString = SDL_GetScancodeName(event.key.keysym.scancode); msg->customData["Key"] = CustomAttribute(keyCodeString); //whether it was key down or key up msg->customData["bKeyDown"] = CustomAttribute(true); } else if (event.type == SDL_KEYUP) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_KEYBOARD); //The key code stringType keyCodeString = SDL_GetScancodeName(event.key.keysym.scancode); msg->customData["Key"] = CustomAttribute(keyCodeString); //whether it was key down or key up msg->customData["bKeyDown"] = CustomAttribute(false); } else if (event.type == SDL_TEXTEDITING) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TEXT_EDIT); } else if (event.type == SDL_TEXTINPUT) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TEXT_INPUT); } else if (event.type == SDL_MOUSEMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_MOUSE_MOVE); floatType xPosition = event.motion.x; floatType yPosition = event.motion.y; msg->customData["x"] = CustomAttribute(xPosition); msg->customData["y"] = CustomAttribute(yPosition); floatType xRelative = event.motion.xrel; floatType yRelative = event.motion.yrel; msg->customData["xrel"] = CustomAttribute(xRelative); msg->customData["yrel"] = CustomAttribute(yRelative); } else if (event.type == SDL_MOUSEBUTTONDOWN) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_MOUSE_BUTTON); } else if (event.type == SDL_MOUSEBUTTONUP) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_MOUSE_BUTTON); } else if (event.type == SDL_MOUSEWHEEL) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_MOUSE_WHEEL); } else if (event.type == SDL_JOYAXISMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_AXIS); } else if (event.type == SDL_JOYBALLMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_BALL); } else if (event.type == SDL_JOYHATMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_HAT); } else if (event.type == SDL_JOYBUTTONDOWN) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_BUTTON); } else if (event.type == SDL_JOYBUTTONUP) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_BUTTON); } else if (event.type == SDL_JOYDEVICEADDED) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_DEVICE); } else if (event.type == SDL_JOYDEVICEREMOVED) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_JOYSTICK_DEVICE); } else if (event.type == SDL_CONTROLLERAXISMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_AXIS); } else if (event.type == SDL_CONTROLLERBUTTONDOWN) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_BUTTON); } else if (event.type == SDL_CONTROLLERBUTTONUP) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_BUTTON); } else if (event.type == SDL_CONTROLLERDEVICEADDED) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_DEVICE); } else if (event.type == SDL_CONTROLLERDEVICEREMOVED) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_DEVICE); } else if (event.type == SDL_CONTROLLERDEVICEREMAPPED) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_CONTROLLER_DEVICE); } else if (event.type == SDL_FINGERDOWN) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TOUCH_SINGLE); } else if (event.type == SDL_FINGERUP) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TOUCH_SINGLE); } else if (event.type == SDL_FINGERMOTION) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TOUCH_SINGLE); } else if (event.type == SDL_DOLLARGESTURE) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TOUCH_DOLLAR); } else if (event.type == SDL_CLIPBOARDUPDATE) { } else if (event.type == SDL_DROPFILE) { msg = messenger->appendMessage(); msg->setType(enumMessageType::EVENT_TOUCH_SINGLE); } else if (event.type == SDL_LASTEVENT) { } else { msg = messenger->appendMessage(); msg->setType(enumMessageType::NONE); } } //END while(... }
SDL_Scancode sdlScancode = WINRT_TranslateKeycode((int)args->VirtualKey, args->KeyStatus.ScanCode); #if 0 SDL_Keycode keycode = SDL_GetKeyFromScancode(sdlScancode); SDL_Log("key down, handled=%s, ext?=%s, released?=%s, menu key down?=%s, " "repeat count=%d, native scan code=0x%x, was down?=%s, vkey=%d, " "sdl scan code=%d (%s), sdl key code=%d (%s)\n", (args->Handled ? "1" : "0"), (args->KeyStatus.IsExtendedKey ? "1" : "0"), (args->KeyStatus.IsKeyReleased ? "1" : "0"), (args->KeyStatus.IsMenuKeyDown ? "1" : "0"), args->KeyStatus.RepeatCount, args->KeyStatus.ScanCode, (args->KeyStatus.WasKeyDown ? "1" : "0"), args->VirtualKey, sdlScancode, SDL_GetScancodeName(sdlScancode), keycode, SDL_GetKeyName(keycode)); //args->Handled = true; #endif SDL_SendKeyboardKey(SDL_PRESSED, sdlScancode); } void WINRT_ProcessKeyUpEvent(Windows::UI::Core::KeyEventArgs ^args) { SDL_Scancode sdlScancode = WINRT_TranslateKeycode((int)args->VirtualKey, args->KeyStatus.ScanCode); #if 0 SDL_Keycode keycode = SDL_GetKeyFromScancode(sdlScancode); SDL_Log("key up, handled=%s, ext?=%s, released?=%s, menu key down?=%s, " "repeat count=%d, native scan code=0x%x, was down?=%s, vkey=%d, "
int X11_InitKeyboard(_THIS) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; int i = 0; int j = 0; int min_keycode, max_keycode; struct { SDL_Scancode scancode; KeySym keysym; int value; } fingerprint[] = { { SDL_SCANCODE_HOME, XK_Home, 0 }, { SDL_SCANCODE_PAGEUP, XK_Prior, 0 }, { SDL_SCANCODE_UP, XK_Up, 0 }, { SDL_SCANCODE_LEFT, XK_Left, 0 }, { SDL_SCANCODE_DELETE, XK_Delete, 0 }, { SDL_SCANCODE_KP_ENTER, XK_KP_Enter, 0 }, }; int best_distance; int best_index; int distance; BOOL xkb_repeat = 0; X11_XAutoRepeatOn(data->display); #if SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM { int xkb_major = XkbMajorVersion; int xkb_minor = XkbMinorVersion; if (X11_XkbQueryExtension(data->display, NULL, NULL, NULL, &xkb_major, &xkb_minor)) { data->xkb = X11_XkbGetMap(data->display, XkbAllClientInfoMask, XkbUseCoreKbd); } /* This will remove KeyRelease events for held keys */ X11_XkbSetDetectableAutoRepeat(data->display, True, &xkb_repeat); } #endif /* Open a connection to the X input manager */ #ifdef X_HAVE_UTF8_STRING if (SDL_X11_HAVE_UTF8) { /* Set the locale, and call XSetLocaleModifiers before XOpenIM so that Compose keys will work correctly. */ char *prev_locale = setlocale(LC_ALL, NULL); char *prev_xmods = X11_XSetLocaleModifiers(NULL); const char *new_xmods = ""; #if defined(HAVE_IBUS_IBUS_H) || defined(HAVE_FCITX_FRONTEND_H) const char *env_xmods = SDL_getenv("XMODIFIERS"); #endif SDL_bool has_dbus_ime_support = SDL_FALSE; if (prev_locale) { prev_locale = SDL_strdup(prev_locale); } if (prev_xmods) { prev_xmods = SDL_strdup(prev_xmods); } /* IBus resends some key events that were filtered by XFilterEvents when it is used via XIM which causes issues. Prevent this by forcing @im=none if XMODIFIERS contains @im=ibus. IBus can still be used via the DBus implementation, which also has support for pre-editing. */ #ifdef HAVE_IBUS_IBUS_H if (env_xmods && SDL_strstr(env_xmods, "@im=ibus") != NULL) { has_dbus_ime_support = SDL_TRUE; } #endif #ifdef HAVE_FCITX_FRONTEND_H if (env_xmods && SDL_strstr(env_xmods, "@im=fcitx") != NULL) { has_dbus_ime_support = SDL_TRUE; } #endif if (has_dbus_ime_support || !xkb_repeat) { new_xmods = "@im=none"; } setlocale(LC_ALL, ""); X11_XSetLocaleModifiers(new_xmods); data->im = X11_XOpenIM(data->display, NULL, data->classname, data->classname); /* Reset the locale + X locale modifiers back to how they were, locale first because the X locale modifiers depend on it. */ setlocale(LC_ALL, prev_locale); X11_XSetLocaleModifiers(prev_xmods); if (prev_locale) { SDL_free(prev_locale); } if (prev_xmods) { SDL_free(prev_xmods); } } #endif /* Try to determine which scancodes are being used based on fingerprint */ best_distance = SDL_arraysize(fingerprint) + 1; best_index = -1; X11_XDisplayKeycodes(data->display, &min_keycode, &max_keycode); for (i = 0; i < SDL_arraysize(fingerprint); ++i) { fingerprint[i].value = X11_XKeysymToKeycode(data->display, fingerprint[i].keysym) - min_keycode; } for (i = 0; i < SDL_arraysize(scancode_set); ++i) { /* Make sure the scancode set isn't too big */ if ((max_keycode - min_keycode + 1) <= scancode_set[i].table_size) { continue; } distance = 0; for (j = 0; j < SDL_arraysize(fingerprint); ++j) { if (fingerprint[j].value < 0 || fingerprint[j].value >= scancode_set[i].table_size) { distance += 1; } else if (scancode_set[i].table[fingerprint[j].value] != fingerprint[j].scancode) { distance += 1; } } if (distance < best_distance) { best_distance = distance; best_index = i; } } if (best_index >= 0 && best_distance <= 2) { #ifdef DEBUG_KEYBOARD printf("Using scancode set %d, min_keycode = %d, max_keycode = %d, table_size = %d\n", best_index, min_keycode, max_keycode, scancode_set[best_index].table_size); #endif SDL_memcpy(&data->key_layout[min_keycode], scancode_set[best_index].table, sizeof(SDL_Scancode) * scancode_set[best_index].table_size); } else { SDL_Keycode keymap[SDL_NUM_SCANCODES]; printf ("Keyboard layout unknown, please send the following to the SDL mailing list ([email protected]):\n"); /* Determine key_layout - only works on US QWERTY layout */ SDL_GetDefaultKeymap(keymap); for (i = min_keycode; i <= max_keycode; ++i) { KeySym sym; sym = X11_KeyCodeToSym(_this, (KeyCode) i, 0); if (sym != NoSymbol) { SDL_Scancode scancode; printf("code = %d, sym = 0x%X (%s) ", i - min_keycode, (unsigned int) sym, X11_XKeysymToString(sym)); scancode = X11_KeyCodeToSDLScancode(_this, i); data->key_layout[i] = scancode; if (scancode == SDL_SCANCODE_UNKNOWN) { printf("scancode not found\n"); } else { printf("scancode = %d (%s)\n", scancode, SDL_GetScancodeName(scancode)); } } } } X11_UpdateKeymap(_this); SDL_SetScancodeName(SDL_SCANCODE_APPLICATION, "Menu"); #ifdef SDL_USE_IME SDL_IME_Init(); #endif return 0; }
int X11_InitKeyboard(_THIS) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; int i = 0; int j = 0; int min_keycode, max_keycode; struct { SDL_Scancode scancode; KeySym keysym; int value; } fingerprint[] = { { SDL_SCANCODE_HOME, XK_Home, 0 }, { SDL_SCANCODE_PAGEUP, XK_Prior, 0 }, { SDL_SCANCODE_UP, XK_Up, 0 }, { SDL_SCANCODE_LEFT, XK_Left, 0 }, { SDL_SCANCODE_DELETE, XK_Delete, 0 }, { SDL_SCANCODE_KP_ENTER, XK_KP_Enter, 0 }, }; int best_distance; int best_index; int distance; X11_XAutoRepeatOn(data->display); /* Try to determine which scancodes are being used based on fingerprint */ best_distance = SDL_arraysize(fingerprint) + 1; best_index = -1; X11_XDisplayKeycodes(data->display, &min_keycode, &max_keycode); for (i = 0; i < SDL_arraysize(fingerprint); ++i) { fingerprint[i].value = X11_XKeysymToKeycode(data->display, fingerprint[i].keysym) - min_keycode; } for (i = 0; i < SDL_arraysize(scancode_set); ++i) { /* Make sure the scancode set isn't too big */ if ((max_keycode - min_keycode + 1) <= scancode_set[i].table_size) { continue; } distance = 0; for (j = 0; j < SDL_arraysize(fingerprint); ++j) { if (fingerprint[j].value < 0 || fingerprint[j].value >= scancode_set[i].table_size) { distance += 1; } else if (scancode_set[i].table[fingerprint[j].value] != fingerprint[j].scancode) { distance += 1; } } if (distance < best_distance) { best_distance = distance; best_index = i; } } if (best_index >= 0 && best_distance <= 2) { #ifdef DEBUG_KEYBOARD printf("Using scancode set %d, min_keycode = %d, max_keycode = %d, table_size = %d\n", best_index, min_keycode, max_keycode, scancode_set[best_index].table_size); #endif SDL_memcpy(&data->key_layout[min_keycode], scancode_set[best_index].table, sizeof(SDL_Scancode) * scancode_set[best_index].table_size); } else { SDL_Keycode keymap[SDL_NUM_SCANCODES]; printf ("Keyboard layout unknown, please send the following to the SDL mailing list ([email protected]):\n"); /* Determine key_layout - only works on US QWERTY layout */ SDL_GetDefaultKeymap(keymap); for (i = min_keycode; i <= max_keycode; ++i) { KeySym sym; #if SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM sym = X11_XkbKeycodeToKeysym(data->display, i, 0, 0); #else sym = X11_XKeycodeToKeysym(data->display, i, 0); #endif if (sym != NoSymbol) { SDL_Scancode scancode; printf("code = %d, sym = 0x%X (%s) ", i - min_keycode, (unsigned int) sym, X11_XKeysymToString(sym)); scancode = X11_KeyCodeToSDLScancode(data->display, i); data->key_layout[i] = scancode; if (scancode == SDL_SCANCODE_UNKNOWN) { printf("scancode not found\n"); } else { printf("scancode = %d (%s)\n", scancode, SDL_GetScancodeName(scancode)); } } } } X11_UpdateKeymap(_this); SDL_SetScancodeName(SDL_SCANCODE_APPLICATION, "Menu"); #ifdef SDL_USE_IBUS SDL_IBus_Init(); #endif return 0; }
Uint8 Keymap_GetKeyFromScancode(SDL_Scancode sdlscancode) { Log_Printf(LOG_KEYMAP_LEVEL, "[Keymap] Scancode: %i (%s)\n", sdlscancode, SDL_GetScancodeName(sdlscancode)); switch (sdlscancode) { case SDL_SCANCODE_ESCAPE: return 0x49; case SDL_SCANCODE_1: return 0x4a; case SDL_SCANCODE_2: return 0x4b; case SDL_SCANCODE_3: return 0x4c; case SDL_SCANCODE_4: return 0x4d; case SDL_SCANCODE_5: return 0x50; case SDL_SCANCODE_6: return 0x4f; case SDL_SCANCODE_7: return 0x4e; case SDL_SCANCODE_8: return 0x1e; case SDL_SCANCODE_9: return 0x1f; case SDL_SCANCODE_0: return 0x20; case SDL_SCANCODE_MINUS: return 0x1d; case SDL_SCANCODE_EQUALS: return 0x1c; case SDL_SCANCODE_BACKSPACE: return 0x1b; case SDL_SCANCODE_TAB: return 0x41; case SDL_SCANCODE_Q: return 0x42; case SDL_SCANCODE_W: return 0x43; case SDL_SCANCODE_E: return 0x44; case SDL_SCANCODE_R: return 0x45; case SDL_SCANCODE_T: return 0x48; case SDL_SCANCODE_Y: return 0x47; case SDL_SCANCODE_U: return 0x46; case SDL_SCANCODE_I: return 0x06; case SDL_SCANCODE_O: return 0x07; case SDL_SCANCODE_P: return 0x08; case SDL_SCANCODE_LEFTBRACKET: return 0x05; case SDL_SCANCODE_RIGHTBRACKET: return 0x04; case SDL_SCANCODE_BACKSLASH: return 0x03; case SDL_SCANCODE_A: return 0x39; case SDL_SCANCODE_S: return 0x3a; case SDL_SCANCODE_D: return 0x3b; case SDL_SCANCODE_F: return 0x3c; case SDL_SCANCODE_G: return 0x3d; case SDL_SCANCODE_H: return 0x40; case SDL_SCANCODE_J: return 0x3f; case SDL_SCANCODE_K: return 0x3e; case SDL_SCANCODE_L: return 0x2d; case SDL_SCANCODE_SEMICOLON: return 0x2c; case SDL_SCANCODE_APOSTROPHE: return 0x2b; case SDL_SCANCODE_RETURN: return 0x2a; case SDL_SCANCODE_Z: return 0x31; case SDL_SCANCODE_X: return 0x32; case SDL_SCANCODE_C: return 0x33; case SDL_SCANCODE_V: return 0x34; case SDL_SCANCODE_B: return 0x35; case SDL_SCANCODE_N: return 0x37; case SDL_SCANCODE_M: return 0x36; case SDL_SCANCODE_COMMA: return 0x2e; case SDL_SCANCODE_PERIOD: return 0x2f; case SDL_SCANCODE_SLASH: return 0x30; case SDL_SCANCODE_SPACE: return 0x38; case SDL_SCANCODE_GRAVE: case SDL_SCANCODE_NUMLOCKCLEAR: return 0x26; case SDL_SCANCODE_KP_EQUALS: return 0x27; case SDL_SCANCODE_KP_DIVIDE: return 0x28; case SDL_SCANCODE_KP_MULTIPLY: return 0x25; case SDL_SCANCODE_KP_7: return 0x21; case SDL_SCANCODE_KP_8: return 0x22; case SDL_SCANCODE_KP_9: return 0x23; case SDL_SCANCODE_KP_MINUS: return 0x24; case SDL_SCANCODE_KP_4: return 0x12; case SDL_SCANCODE_KP_5: return 0x18; case SDL_SCANCODE_KP_6: return 0x13; case SDL_SCANCODE_KP_PLUS: return 0x15; case SDL_SCANCODE_KP_1: return 0x11; case SDL_SCANCODE_KP_2: return 0x17; case SDL_SCANCODE_KP_3: return 0x14; case SDL_SCANCODE_KP_0: return 0x0b; case SDL_SCANCODE_KP_PERIOD: return 0x0c; case SDL_SCANCODE_KP_ENTER: return 0x0d; case SDL_SCANCODE_LEFT: return 0x09; case SDL_SCANCODE_RIGHT: return 0x10; case SDL_SCANCODE_UP: return 0x16; case SDL_SCANCODE_DOWN: return 0x0f; /* Special keys */ case SDL_SCANCODE_F10: case SDL_SCANCODE_DELETE: return 0x58; /* Power */ case SDL_SCANCODE_F5: case SDL_SCANCODE_END: return 0x02; /* Sound down */ case SDL_SCANCODE_F6: case SDL_SCANCODE_HOME: return 0x1a; /* Sound up */ case SDL_SCANCODE_F1: case SDL_SCANCODE_PAGEDOWN: return 0x01; /* Brightness down */ case SDL_SCANCODE_F2: case SDL_SCANCODE_PAGEUP: return 0x19; /* Brightness up */ default: return 0x00; } }
const rString KeyBindingCollection::GetScancodeNameForAction( ActionIdentifier action, KeyBindingType bindType ) const { return rString( SDL_GetScancodeName( ( bindType == KeyBindingType::Primary ? m_ActionToScancodePrimary : m_ActionToScancodeSecondary ).at( static_cast<int>( action ) ) ) ); }