path: root/c_src/sdl_keyboard.c

// Copyright (c) 2015-2018, Loïc Hoguin <[email protected]>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#include "esdl2.h"

// get_key_from_name

NIF_FUNCTION(get_key_from_name)
{
	ErlNifBinary bin;
	char* name;
	SDL_Keycode key;

	BADARG_IF(!enif_inspect_binary(env, argv[0], &bin));

	name = malloc(bin.size + 1);
	memcpy(name, bin.data, bin.size);
	name[bin.size] = '\0';

	key = SDL_GetKeyFromName(name);

	free(name);

	if (key == SDLK_UNKNOWN)
		return atom_undefined;

	return enif_make_int(env, key);
}

// get_key_from_scancode

NIF_FUNCTION(get_key_from_scancode)
{
	SDL_Scancode scancode;
	SDL_Keycode key;

	BADARG_IF(!enif_get_uint(env, argv[0], &scancode));

	key = SDL_GetKeyFromScancode(scancode);

	if (key == SDLK_UNKNOWN)
		return atom_undefined;

	return enif_make_int(env, key);
}

// get_key_name
//
// SDL_GetKeyName is not thread-safe as it stores the returned
// value in a static array in at least some cases. We use the
// NIF thread to avoid any issues.

NIF_CALL_HANDLER(thread_get_key_name)
{
	const char* name;
	ErlNifBinary bin;

	name = SDL_GetKeyName((long)args[0]);

	enif_alloc_binary(strlen(name), &bin);

	memcpy(bin.data, name, bin.size);

	return enif_make_binary(env, &bin);
}

NIF_FUNCTION(get_key_name)
{
	SDL_Keycode key;

	BADARG_IF(!enif_get_int(env, argv[0], &key));

	return nif_thread_call(env, thread_get_key_name, 1, key);
}

// get_scancode_from_key

NIF_FUNCTION(get_scancode_from_key)
{
	SDL_Keycode key;
	SDL_Scancode scancode;

	BADARG_IF(!enif_get_int(env, argv[0], &key));

	scancode = SDL_GetScancodeFromKey(key);

	if (scancode == SDL_SCANCODE_UNKNOWN)
		return atom_undefined;

	return enif_make_uint(env, scancode);
}

// get_scancode_from_name

NIF_FUNCTION(get_scancode_from_name)
{
	ErlNifBinary bin;
	char* name;
	SDL_Scancode scancode;

	BADARG_IF(!enif_inspect_binary(env, argv[0], &bin));

	name = malloc(bin.size + 1);
	memcpy(name, bin.data, bin.size);
	name[bin.size] = '\0';

	scancode = SDL_GetScancodeFromName(name);

	free(name);

	if (scancode == SDL_SCANCODE_UNKNOWN)
		return atom_undefined;

	return enif_make_uint(env, scancode);
}

// get_scancode_name
//
// The SDL_GetScancodeName function only ever points to static
// data and is therefore thread-safe, unlike SDL_GetKeyName.

NIF_FUNCTION(get_scancode_name)
{
	SDL_Scancode scancode;
	const char* name;
	ErlNifBinary bin;

	BADARG_IF(!enif_get_uint(env, argv[0], &scancode));

	name = SDL_GetScancodeName(scancode);

	enif_alloc_binary(strlen(name), &bin);

	memcpy(bin.data, name, bin.size);

	return enif_make_binary(env, &bin);
}

// get_keyboard_focus

NIF_CALL_HANDLER(thread_get_keyboard_focus)
{
	SDL_Window* window;

	window = SDL_GetKeyboardFocus();

	if (!window)
		return atom_undefined;

	return esdl2_windows_find(env, window);
}

NIF_FUNCTION(get_keyboard_focus)
{
	return nif_thread_call(env, thread_get_keyboard_focus, 0);
}

// get_keyboard_state

NIF_CALL_HANDLER(thread_get_keyboard_state)
{
	const Uint8* state;
	int i, numkeys;
	ERL_NIF_TERM map;

	state = SDL_GetKeyboardState(&numkeys);

	map = enif_make_new_map(env);

	for (i = 0; i < numkeys; i++) {
		enif_make_map_put(env, map,
			enif_make_int(env, i),
			state[i] ? atom_true : atom_false,
			&map);
	}

	return map;
}

NIF_FUNCTION(get_keyboard_state)
{
	return nif_thread_call(env, thread_get_keyboard_state, 0);
}

// get_mod_state

NIF_CALL_HANDLER(thread_get_mod_state)
{
	SDL_Keymod mod;

	mod = SDL_GetModState();

	return keymod_flags_to_list(env, mod);
}

NIF_FUNCTION(get_mod_state)
{
	return nif_thread_call(env, thread_get_mod_state, 0);
}

// has_screen_keyboard_support

NIF_CALL_HANDLER(thread_has_screen_keyboard_support)
{
	if (SDL_HasScreenKeyboardSupport())
		return atom_true;

	return atom_false;
}

NIF_FUNCTION(has_screen_keyboard_support)
{
	return nif_thread_call(env, thread_has_screen_keyboard_support, 0);
}

// is_screen_keyboard_shown

NIF_CALL_HANDLER(thread_is_screen_keyboard_shown)
{
	if (SDL_IsScreenKeyboardShown(args[0]))
		return atom_true;

	return atom_false;
}

NIF_FUNCTION(is_screen_keyboard_shown)
{
	void* window_res;

	BADARG_IF(!enif_get_resource(env, argv[0], res_Window, &window_res));

	return nif_thread_call(env, thread_is_screen_keyboard_shown, 1,
		NIF_RES_GET(Window, window_res));
}

// is_text_input_active

NIF_CALL_HANDLER(thread_is_text_input_active)
{
	if (SDL_IsTextInputActive())
		return atom_true;

	return atom_false;
}

NIF_FUNCTION(is_text_input_active)
{
	return nif_thread_call(env, thread_is_text_input_active, 0);
}

// set_mod_state

NIF_CAST_HANDLER(thread_set_mod_state)
{
	SDL_SetModState((long)args[0]);
}

NIF_FUNCTION(set_mod_state)
{
	Uint16 mod;

	BADARG_IF(!keymod_list_to_flags(env, argv[0], &mod));

	return nif_thread_cast(env, thread_set_mod_state, 1, mod);
}

// set_text_input_rect

NIF_CAST_HANDLER(thread_set_text_input_rect)
{
	SDL_SetTextInputRect(args[0]);
}

NIF_FUNCTION(set_text_input_rect)
{
	SDL_Rect* rect = NULL;

	rect = (SDL_Rect*)enif_alloc(sizeof(SDL_Rect));
	if (!map_to_rect(env, argv[0], rect)) {
		enif_free(rect);
		return enif_make_badarg(env);
	}

	return nif_thread_cast(env, thread_set_text_input_rect, 1, rect);
}

// start_text_input

NIF_CAST_HANDLER(thread_start_text_input)
{
	SDL_StartTextInput();
}

NIF_FUNCTION(start_text_input)
{
	return nif_thread_cast(env, thread_start_text_input, 0);
}

// stop_text_input

NIF_CAST_HANDLER(thread_stop_text_input)
{
	SDL_StopTextInput();
}

NIF_FUNCTION(stop_text_input)
{
	return nif_thread_cast(env, thread_stop_text_input, 0);
}