Example #1
0
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 ) ) );
		}
	}
}
Example #2
0
/**
 * @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;
}
Example #3
0
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);
}
Example #5
0
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);
        }
    }
}
Example #6
0
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);
		}
	}



}
Example #7
0
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;
}
Example #8
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));
}
Example #9
0
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";
		}	
	}
Example #10
0
/*
===============
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 ) );
}
Example #11
0
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);
    }
}
Example #12
0
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
}
Example #13
0
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();
    }
}
Example #14
0
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;
		}
		
	}
	
}
Example #16
0
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());


}
Example #17
0
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));
}
Example #19
0
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;
		}
	}
}
Example #21
0
	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();
				}
			}
		}

		
	}
Example #22
0
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");
}
Example #23
0
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");
}
Example #24
0
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);
	}
}
Example #25
0
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, "
Example #27
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;
    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;
}
Example #29
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 ) ) ) );
}