mirror of
https://github.com/CTCaer/RetroArch.git
synced 2025-01-12 13:51:27 +00:00
354 lines
10 KiB
C
354 lines
10 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
|
* Copyright (C) 2011-2014 - Daniel De Matteis
|
|
*
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "../../config.h"
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include "menu_common.h"
|
|
#include "../../input/keyboard_line.h"
|
|
#include "menu_input_line_cb.h"
|
|
#include "../../settings_data.h"
|
|
|
|
/* forward decls */
|
|
void menu_common_setting_set_current_string(rarch_setting_t *setting,
|
|
const char *str);
|
|
void menu_common_set_current_string_based_on_label(
|
|
const char *label, const char *str);
|
|
|
|
void menu_key_start_line(void *data, const char *label,
|
|
const char *label_setting, input_keyboard_line_complete_t cb)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)data;
|
|
|
|
if (!menu)
|
|
return;
|
|
|
|
menu->keyboard.display = true;
|
|
menu->keyboard.label = label;
|
|
menu->keyboard.label_setting = label_setting;
|
|
menu->keyboard.buffer = input_keyboard_start_line(menu, cb);
|
|
}
|
|
|
|
static void menu_key_end_line(void *data)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)data;
|
|
|
|
if (!menu)
|
|
return;
|
|
|
|
menu->keyboard.display = false;
|
|
menu->keyboard.label = NULL;
|
|
menu->keyboard.label_setting = NULL;
|
|
|
|
/* Avoid triggering states on pressing return. */
|
|
menu->old_input_state = -1ULL;
|
|
}
|
|
|
|
static void menu_search_callback(void *userdata, const char *str)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)userdata;
|
|
|
|
if (str && *str)
|
|
file_list_search(menu->selection_buf, str, &menu->selection_ptr);
|
|
menu_key_end_line(menu);
|
|
}
|
|
|
|
void st_uint_callback(void *userdata, const char *str)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)userdata;
|
|
rarch_setting_t *current_setting = NULL;
|
|
rarch_setting_t *setting_data = (rarch_setting_t *)setting_data_get_list();
|
|
|
|
if (str && *str && setting_data)
|
|
{
|
|
if ((current_setting = (rarch_setting_t*)
|
|
setting_data_find_setting(
|
|
setting_data, menu->keyboard.label_setting)))
|
|
*current_setting->value.unsigned_integer = strtoul(str, NULL, 0);
|
|
}
|
|
menu_key_end_line(menu);
|
|
}
|
|
|
|
void st_string_callback(void *userdata, const char *str)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)userdata;
|
|
rarch_setting_t *current_setting = NULL;
|
|
rarch_setting_t *setting_data = (rarch_setting_t *)setting_data_get_list();
|
|
|
|
if (str && *str && setting_data)
|
|
{
|
|
if ((current_setting = (rarch_setting_t*)
|
|
setting_data_find_setting(
|
|
setting_data, menu->keyboard.label_setting)))
|
|
menu_common_setting_set_current_string(current_setting, str);
|
|
else
|
|
menu_common_set_current_string_based_on_label(menu->keyboard.label_setting, str);
|
|
}
|
|
menu_key_end_line(menu);
|
|
}
|
|
|
|
void menu_key_event(bool down, unsigned keycode, uint32_t character, uint16_t mod)
|
|
{
|
|
if (!driver.menu)
|
|
{
|
|
RARCH_ERR("Cannot invoke menu key event callback, menu handle is not initialized.\n");
|
|
return;
|
|
}
|
|
|
|
(void)down;
|
|
(void)keycode;
|
|
(void)mod;
|
|
|
|
if (character == '/')
|
|
{
|
|
driver.menu->keyboard.display = true;
|
|
driver.menu->keyboard.label = "Search: ";
|
|
driver.menu->keyboard.buffer =
|
|
input_keyboard_start_line(driver.menu, menu_search_callback);
|
|
}
|
|
}
|
|
|
|
void menu_poll_bind_state(struct menu_bind_state *state)
|
|
{
|
|
unsigned i, b, a, h;
|
|
const rarch_joypad_driver_t *joypad = NULL;
|
|
|
|
if (!state)
|
|
return;
|
|
|
|
memset(state->state, 0, sizeof(state->state));
|
|
state->skip = driver.input->input_state(driver.input_data, NULL, 0,
|
|
RETRO_DEVICE_KEYBOARD, 0, RETROK_RETURN);
|
|
|
|
if (driver.input && driver.input_data && driver.input->get_joypad_driver)
|
|
joypad = driver.input->get_joypad_driver(driver.input_data);
|
|
|
|
if (!joypad)
|
|
{
|
|
RARCH_ERR("Cannot poll raw joypad state.");
|
|
return;
|
|
}
|
|
|
|
if (joypad->poll)
|
|
joypad->poll();
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
{
|
|
for (b = 0; b < MENU_MAX_BUTTONS; b++)
|
|
state->state[i].buttons[b] = input_joypad_button_raw(joypad, i, b);
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
|
state->state[i].axes[a] = input_joypad_axis_raw(joypad, i, a);
|
|
for (h = 0; h < MENU_MAX_HATS; h++)
|
|
{
|
|
state->state[i].hats[h] |=
|
|
input_joypad_hat_raw(joypad, i, HAT_UP_MASK, h) ? HAT_UP_MASK : 0;
|
|
state->state[i].hats[h] |=
|
|
input_joypad_hat_raw(joypad, i, HAT_DOWN_MASK, h) ? HAT_DOWN_MASK : 0;
|
|
state->state[i].hats[h] |=
|
|
input_joypad_hat_raw(joypad, i, HAT_LEFT_MASK, h) ? HAT_LEFT_MASK : 0;
|
|
state->state[i].hats[h] |=
|
|
input_joypad_hat_raw(joypad, i, HAT_RIGHT_MASK, h) ? HAT_RIGHT_MASK : 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void menu_poll_bind_get_rested_axes(struct menu_bind_state *state)
|
|
{
|
|
unsigned i, a;
|
|
const rarch_joypad_driver_t *joypad = NULL;
|
|
|
|
if (!state)
|
|
return;
|
|
|
|
if (driver.input && driver.input_data && driver.input->get_joypad_driver)
|
|
joypad = driver.input->get_joypad_driver(driver.input_data);
|
|
|
|
if (!joypad)
|
|
{
|
|
RARCH_ERR("Cannot poll raw joypad state.");
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
|
state->axis_state[i].rested_axes[a] =
|
|
input_joypad_axis_raw(joypad, i, a);
|
|
}
|
|
|
|
static bool menu_poll_find_trigger_pad(struct menu_bind_state *state,
|
|
struct menu_bind_state *new_state, unsigned p)
|
|
{
|
|
unsigned a, b, h;
|
|
const struct menu_bind_state_port *n = (const struct menu_bind_state_port*)
|
|
&new_state->state[p];
|
|
const struct menu_bind_state_port *o = (const struct menu_bind_state_port*)
|
|
&state->state[p];
|
|
|
|
for (b = 0; b < MENU_MAX_BUTTONS; b++)
|
|
{
|
|
if (n->buttons[b] && !o->buttons[b])
|
|
{
|
|
state->target->joykey = b;
|
|
state->target->joyaxis = AXIS_NONE;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* Axes are a bit tricky ... */
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
|
{
|
|
int locked_distance = abs(n->axes[a] -
|
|
new_state->axis_state[p].locked_axes[a]);
|
|
int rested_distance = abs(n->axes[a] -
|
|
new_state->axis_state[p].rested_axes[a]);
|
|
|
|
if (abs(n->axes[a]) >= 20000 &&
|
|
locked_distance >= 20000 &&
|
|
rested_distance >= 20000)
|
|
{
|
|
/* Take care of case where axis rests on +/- 0x7fff
|
|
* (e.g. 360 controller on Linux) */
|
|
state->target->joyaxis = n->axes[a] > 0 ? AXIS_POS(a) : AXIS_NEG(a);
|
|
state->target->joykey = NO_BTN;
|
|
|
|
/* Lock the current axis */
|
|
new_state->axis_state[p].locked_axes[a] = n->axes[a] > 0 ? 0x7fff : -0x7fff;
|
|
return true;
|
|
}
|
|
|
|
if (locked_distance >= 20000) /* Unlock the axis. */
|
|
new_state->axis_state[p].locked_axes[a] = 0;
|
|
}
|
|
|
|
for (h = 0; h < MENU_MAX_HATS; h++)
|
|
{
|
|
uint16_t trigged = n->hats[h] & (~o->hats[h]);
|
|
uint16_t sane_trigger = 0;
|
|
|
|
if (trigged & HAT_UP_MASK)
|
|
sane_trigger = HAT_UP_MASK;
|
|
else if (trigged & HAT_DOWN_MASK)
|
|
sane_trigger = HAT_DOWN_MASK;
|
|
else if (trigged & HAT_LEFT_MASK)
|
|
sane_trigger = HAT_LEFT_MASK;
|
|
else if (trigged & HAT_RIGHT_MASK)
|
|
sane_trigger = HAT_RIGHT_MASK;
|
|
|
|
if (sane_trigger)
|
|
{
|
|
state->target->joykey = HAT_MAP(h, sane_trigger);
|
|
state->target->joyaxis = AXIS_NONE;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool menu_poll_find_trigger(struct menu_bind_state *state,
|
|
struct menu_bind_state *new_state)
|
|
{
|
|
unsigned i;
|
|
|
|
if (!state || !new_state)
|
|
return false;
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
{
|
|
if (menu_poll_find_trigger_pad(state, new_state, i))
|
|
{
|
|
/* Update the joypad mapping automatically.
|
|
* More friendly that way. */
|
|
g_settings.input.joypad_map[state->player] = i;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool menu_custom_bind_keyboard_cb(void *data, unsigned code)
|
|
{
|
|
menu_handle_t *menu = (menu_handle_t*)data;
|
|
|
|
if (!menu)
|
|
return false;
|
|
|
|
menu->binds.target->key = (enum retro_key)code;
|
|
menu->binds.begin++;
|
|
menu->binds.target++;
|
|
menu->binds.timeout_end = rarch_get_time_usec() +
|
|
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
|
|
|
|
return menu->binds.begin <= menu->binds.last;
|
|
}
|
|
|
|
uint64_t menu_input(void)
|
|
{
|
|
unsigned i;
|
|
uint64_t input_state = 0;
|
|
static const struct retro_keybind *binds[] = { g_settings.input.binds[0] };
|
|
|
|
if (!driver.menu)
|
|
return 0;
|
|
|
|
input_push_analog_dpad((struct retro_keybind*)binds[0],
|
|
(g_settings.input.analog_dpad_mode[0] == ANALOG_DPAD_NONE) ?
|
|
ANALOG_DPAD_LSTICK : g_settings.input.analog_dpad_mode[0]);
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
input_push_analog_dpad(g_settings.input.autoconf_binds[i],
|
|
g_settings.input.analog_dpad_mode[i]);
|
|
|
|
if (!driver.block_libretro_input)
|
|
{
|
|
for (i = 0; i < RETRO_DEVICE_ID_JOYPAD_R2; i++)
|
|
{
|
|
input_state |= driver.input->input_state(driver.input_data, binds,
|
|
0, RETRO_DEVICE_JOYPAD, 0, i) ? (1ULL << i) : 0;
|
|
#ifdef HAVE_OVERLAY
|
|
input_state |= (driver.overlay_state.buttons & (UINT64_C(1) << i))
|
|
? (1ULL << i) : 0;
|
|
#endif
|
|
}
|
|
}
|
|
input_state |= input_key_pressed_func(RARCH_MENU_TOGGLE)
|
|
? (1ULL << RARCH_MENU_TOGGLE) : 0;
|
|
|
|
input_pop_analog_dpad((struct retro_keybind*)binds[0]);
|
|
for (i = 0; i < MAX_PLAYERS; i++)
|
|
input_pop_analog_dpad(g_settings.input.autoconf_binds[i]);
|
|
|
|
driver.menu->trigger_state = input_state & ~driver.menu->old_input_state;
|
|
|
|
driver.menu->do_held = (input_state & (
|
|
(1ULL << RETRO_DEVICE_ID_JOYPAD_UP)
|
|
| (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN)
|
|
| (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT)
|
|
| (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT)
|
|
| (1ULL << RETRO_DEVICE_ID_JOYPAD_L)
|
|
| (1ULL << RETRO_DEVICE_ID_JOYPAD_R)
|
|
)) && !(input_state & (1ULL << RARCH_MENU_TOGGLE));
|
|
|
|
return input_state;
|
|
}
|