2014-03-02 04:24:57 +00:00
|
|
|
/* RetroArch - A frontend for libretro.
|
|
|
|
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
|
2015-01-07 16:46:50 +00:00
|
|
|
* Copyright (C) 2011-2015 - Daniel De Matteis
|
2014-04-13 10:12:12 +00:00
|
|
|
*
|
2014-03-02 04:24:57 +00:00
|
|
|
* 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/>.
|
|
|
|
*/
|
2014-03-02 10:45:41 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "../../config.h"
|
|
|
|
#endif
|
|
|
|
|
2014-03-02 04:24:57 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2015-06-05 15:56:51 +00:00
|
|
|
|
|
|
|
#include <rhash.h>
|
|
|
|
|
2015-01-11 05:24:44 +00:00
|
|
|
#include "menu_input.h"
|
2015-01-10 03:53:37 +00:00
|
|
|
#include "menu.h"
|
2015-05-11 09:48:43 +00:00
|
|
|
#include "menu_entry.h"
|
2015-02-14 00:51:28 +00:00
|
|
|
#include "menu_setting.h"
|
2014-10-28 20:49:50 +00:00
|
|
|
#include "menu_shader.h"
|
2015-02-11 21:15:13 +00:00
|
|
|
#include "menu_navigation.h"
|
2015-01-19 18:00:26 +00:00
|
|
|
#include "../cheats.h"
|
2014-10-28 18:54:23 +00:00
|
|
|
#include "../performance.h"
|
2015-01-10 19:10:45 +00:00
|
|
|
#include "../input/input_joypad.h"
|
2015-01-19 17:16:34 +00:00
|
|
|
#include "../input/input_remapping.h"
|
2015-01-19 07:37:11 +00:00
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
void menu_input_key_start_line(const char *label,
|
2014-12-06 14:47:25 +00:00
|
|
|
const char *label_setting, unsigned type, unsigned idx,
|
|
|
|
input_keyboard_line_complete_t cb)
|
2014-03-02 10:45:41 +00:00
|
|
|
{
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2014-06-10 00:06:10 +00:00
|
|
|
if (!menu)
|
2014-04-26 00:08:03 +00:00
|
|
|
return;
|
|
|
|
|
2014-08-25 12:53:03 +00:00
|
|
|
menu->keyboard.display = true;
|
|
|
|
menu->keyboard.label = label;
|
|
|
|
menu->keyboard.label_setting = label_setting;
|
2014-12-06 14:47:25 +00:00
|
|
|
menu->keyboard.type = type;
|
|
|
|
menu->keyboard.idx = idx;
|
2014-08-25 12:53:03 +00:00
|
|
|
menu->keyboard.buffer = input_keyboard_start_line(menu, cb);
|
2014-03-02 10:45:41 +00:00
|
|
|
}
|
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
static void menu_input_key_end_line(void)
|
2014-03-02 10:45:41 +00:00
|
|
|
{
|
2015-03-18 18:40:00 +00:00
|
|
|
driver_t *driver = driver_get_ptr();
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2014-06-10 00:06:10 +00:00
|
|
|
if (!menu)
|
2014-04-26 00:08:03 +00:00
|
|
|
return;
|
|
|
|
|
2014-08-25 12:53:03 +00:00
|
|
|
menu->keyboard.display = false;
|
|
|
|
menu->keyboard.label = NULL;
|
|
|
|
menu->keyboard.label_setting = NULL;
|
2014-08-20 14:26:34 +00:00
|
|
|
|
|
|
|
/* Avoid triggering states on pressing return. */
|
2015-03-18 18:40:00 +00:00
|
|
|
driver->flushing_input = true;
|
2014-03-02 10:45:41 +00:00
|
|
|
}
|
2014-03-02 04:24:57 +00:00
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
static void menu_input_search_callback(void *userdata, const char *str)
|
2014-03-02 04:24:57 +00:00
|
|
|
{
|
2015-05-13 01:35:07 +00:00
|
|
|
size_t idx = 0;
|
2015-05-07 03:31:25 +00:00
|
|
|
menu_list_t *menu_list = menu_list_get_ptr();
|
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
2014-10-12 03:03:22 +00:00
|
|
|
|
2015-05-07 03:31:25 +00:00
|
|
|
if (!menu_list || !nav)
|
2015-02-10 22:26:21 +00:00
|
|
|
return;
|
|
|
|
|
2015-05-07 03:31:25 +00:00
|
|
|
if (str && *str && file_list_search(menu_list->selection_buf, str, &idx))
|
|
|
|
menu_navigation_set(nav, idx, true);
|
2014-03-02 04:24:57 +00:00
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
menu_input_key_end_line();
|
2014-03-02 10:45:41 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
void menu_input_st_uint_callback(void *userdata, const char *str)
|
2014-03-02 10:45:41 +00:00
|
|
|
{
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-02-10 22:26:21 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return;
|
2014-03-02 10:45:41 +00:00
|
|
|
|
2014-10-08 22:50:35 +00:00
|
|
|
if (str && *str)
|
2014-08-24 17:00:36 +00:00
|
|
|
{
|
2015-02-10 22:26:21 +00:00
|
|
|
rarch_setting_t *current_setting = NULL;
|
2015-05-08 15:19:43 +00:00
|
|
|
if ((current_setting = menu_setting_find(menu->keyboard.label_setting)))
|
2015-06-02 05:27:10 +00:00
|
|
|
setting_set_with_string_representation(current_setting, str);
|
2014-08-24 17:00:36 +00:00
|
|
|
}
|
2015-02-10 22:26:21 +00:00
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
menu_input_key_end_line();
|
2014-03-02 10:45:41 +00:00
|
|
|
}
|
|
|
|
|
2015-03-14 22:21:55 +00:00
|
|
|
void menu_input_st_hex_callback(void *userdata, const char *str)
|
|
|
|
{
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-03-14 22:21:55 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (str && *str)
|
|
|
|
{
|
|
|
|
rarch_setting_t *current_setting = NULL;
|
2015-05-08 15:19:43 +00:00
|
|
|
if ((current_setting = menu_setting_find(menu->keyboard.label_setting)))
|
2015-03-14 22:21:55 +00:00
|
|
|
if (str[0] == '#')
|
|
|
|
str++;
|
|
|
|
*current_setting->value.unsigned_integer = strtoul(str, NULL, 16);
|
|
|
|
}
|
|
|
|
|
|
|
|
menu_input_key_end_line();
|
|
|
|
}
|
|
|
|
|
2015-01-19 07:37:11 +00:00
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
void menu_input_st_string_callback(void *userdata, const char *str)
|
2014-03-02 10:45:41 +00:00
|
|
|
{
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-02-10 22:26:21 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return;
|
2015-05-13 01:35:07 +00:00
|
|
|
|
2014-10-08 22:50:35 +00:00
|
|
|
if (str && *str)
|
2014-08-01 05:00:32 +00:00
|
|
|
{
|
2015-03-21 03:43:18 +00:00
|
|
|
global_t *global = global_get_ptr();
|
2015-06-08 12:07:03 +00:00
|
|
|
rarch_setting_t *current_setting = menu_setting_find(menu->keyboard.label_setting);
|
2015-02-10 22:26:21 +00:00
|
|
|
|
2015-06-08 12:07:03 +00:00
|
|
|
if (current_setting)
|
2015-04-15 07:35:48 +00:00
|
|
|
{
|
2015-06-01 19:39:06 +00:00
|
|
|
setting_set_with_string_representation(current_setting, str);
|
2015-06-06 14:26:55 +00:00
|
|
|
menu_setting_generic(current_setting, false);
|
2015-04-15 07:35:48 +00:00
|
|
|
}
|
2014-09-05 23:34:05 +00:00
|
|
|
else
|
2014-10-28 20:49:50 +00:00
|
|
|
{
|
2015-06-05 15:56:51 +00:00
|
|
|
uint32_t hash_label = djb2_calculate(menu->keyboard.label_setting);
|
|
|
|
|
|
|
|
switch (hash_label)
|
|
|
|
{
|
|
|
|
case MENU_LABEL_VIDEO_SHADER_PRESET_SAVE_AS:
|
|
|
|
menu_shader_manager_save_preset(str, false);
|
|
|
|
break;
|
|
|
|
case MENU_LABEL_REMAP_FILE_SAVE_AS:
|
|
|
|
input_remapping_save_file(str);
|
|
|
|
break;
|
|
|
|
case MENU_LABEL_CHEAT_FILE_SAVE_AS:
|
|
|
|
cheat_manager_save(global->cheat, str);
|
|
|
|
break;
|
|
|
|
}
|
2014-10-28 20:49:50 +00:00
|
|
|
}
|
2014-08-01 05:00:32 +00:00
|
|
|
}
|
2015-01-11 05:42:53 +00:00
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
menu_input_key_end_line();
|
2014-03-02 10:45:41 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
void menu_input_st_cheat_callback(void *userdata, const char *str)
|
2014-12-06 14:47:25 +00:00
|
|
|
{
|
2015-03-21 03:43:18 +00:00
|
|
|
global_t *global = global_get_ptr();
|
|
|
|
cheat_manager_t *cheat = global->cheat;
|
2015-02-10 22:26:21 +00:00
|
|
|
menu_handle_t *menu = (menu_handle_t*)userdata;
|
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return;
|
2015-05-13 01:35:07 +00:00
|
|
|
|
2014-12-06 14:47:25 +00:00
|
|
|
if (cheat && str && *str)
|
|
|
|
{
|
|
|
|
unsigned cheat_index = menu->keyboard.type - MENU_SETTINGS_CHEAT_BEGIN;
|
|
|
|
|
|
|
|
cheat->cheats[cheat_index].code = strdup(str);
|
|
|
|
cheat->cheats[cheat_index].state = true;
|
|
|
|
}
|
2015-01-11 05:42:53 +00:00
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
menu_input_key_end_line();
|
2014-12-06 14:47:25 +00:00
|
|
|
}
|
|
|
|
|
2015-02-01 23:53:06 +00:00
|
|
|
void menu_input_search_start(void)
|
|
|
|
{
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-02-13 19:19:20 +00:00
|
|
|
if (!menu)
|
2015-02-01 23:53:06 +00:00
|
|
|
return;
|
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
menu->keyboard.display = true;
|
|
|
|
menu->keyboard.label = "Search: ";
|
2015-05-13 01:35:07 +00:00
|
|
|
menu->keyboard.buffer =
|
2015-04-14 10:56:37 +00:00
|
|
|
input_keyboard_start_line(menu, menu_input_search_callback);
|
2015-02-01 23:53:06 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
void menu_input_key_event(bool down, unsigned keycode,
|
2014-10-11 03:45:18 +00:00
|
|
|
uint32_t character, uint16_t mod)
|
2014-03-02 04:24:57 +00:00
|
|
|
{
|
|
|
|
(void)down;
|
|
|
|
(void)keycode;
|
|
|
|
(void)mod;
|
|
|
|
|
|
|
|
if (character == '/')
|
2015-05-18 15:54:54 +00:00
|
|
|
menu_entry_action(NULL, 0, MENU_ACTION_SEARCH);
|
2014-03-02 04:24:57 +00:00
|
|
|
}
|
2014-03-02 10:45:41 +00:00
|
|
|
|
2015-04-14 11:43:24 +00:00
|
|
|
static void menu_input_poll_bind_state(struct menu_bind_state *state)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2014-08-20 14:26:34 +00:00
|
|
|
unsigned i, b, a, h;
|
2015-04-14 14:37:59 +00:00
|
|
|
const input_device_driver_t *joypad = input_driver_get_joypad_driver();
|
2015-03-23 02:40:09 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2014-08-20 14:26:34 +00:00
|
|
|
|
2014-06-08 17:48:38 +00:00
|
|
|
if (!state)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(state->state, 0, sizeof(state->state));
|
2015-03-23 02:04:05 +00:00
|
|
|
state->skip = input_driver_state(NULL, 0,
|
2014-08-20 14:26:34 +00:00
|
|
|
RETRO_DEVICE_KEYBOARD, 0, RETROK_RETURN);
|
2014-06-08 17:48:38 +00:00
|
|
|
|
|
|
|
if (!joypad)
|
|
|
|
{
|
|
|
|
RARCH_ERR("Cannot poll raw joypad state.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-27 13:08:21 +00:00
|
|
|
if (joypad->poll)
|
2014-08-02 22:44:07 +00:00
|
|
|
joypad->poll();
|
|
|
|
|
2015-03-20 19:43:22 +00:00
|
|
|
for (i = 0; i < settings->input.max_users; i++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2014-06-09 23:42:26 +00:00
|
|
|
for (b = 0; b < MENU_MAX_BUTTONS; b++)
|
2014-06-08 17:48:38 +00:00
|
|
|
state->state[i].buttons[b] = input_joypad_button_raw(joypad, i, b);
|
2015-01-11 05:34:32 +00:00
|
|
|
|
2014-06-09 23:42:26 +00:00
|
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
2014-06-08 17:48:38 +00:00
|
|
|
state->state[i].axes[a] = input_joypad_axis_raw(joypad, i, a);
|
2015-01-11 05:34:32 +00:00
|
|
|
|
2014-06-09 23:42:26 +00:00
|
|
|
for (h = 0; h < MENU_MAX_HATS; h++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2015-01-11 05:34:32 +00:00
|
|
|
if (input_joypad_hat_raw(joypad, i, HAT_UP_MASK, h))
|
|
|
|
state->state[i].hats[h] |= HAT_UP_MASK;
|
|
|
|
if (input_joypad_hat_raw(joypad, i, HAT_DOWN_MASK, h))
|
|
|
|
state->state[i].hats[h] |= HAT_DOWN_MASK;
|
|
|
|
if (input_joypad_hat_raw(joypad, i, HAT_LEFT_MASK, h))
|
|
|
|
state->state[i].hats[h] |= HAT_LEFT_MASK;
|
|
|
|
if (input_joypad_hat_raw(joypad, i, HAT_RIGHT_MASK, h))
|
|
|
|
state->state[i].hats[h] |= HAT_RIGHT_MASK;
|
2014-06-08 17:48:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-14 11:43:24 +00:00
|
|
|
static void menu_input_poll_bind_get_rested_axes(struct menu_bind_state *state)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
|
|
|
unsigned i, a;
|
2015-04-14 14:37:59 +00:00
|
|
|
const input_device_driver_t *joypad = input_driver_get_joypad_driver();
|
2015-03-23 02:40:09 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2014-06-08 17:48:38 +00:00
|
|
|
|
|
|
|
if (!state)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!joypad)
|
|
|
|
{
|
|
|
|
RARCH_ERR("Cannot poll raw joypad state.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-20 19:43:22 +00:00
|
|
|
for (i = 0; i < settings->input.max_users; i++)
|
2014-06-09 23:42:26 +00:00
|
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
2014-09-03 03:10:34 +00:00
|
|
|
state->axis_state[i].rested_axes[a] =
|
|
|
|
input_joypad_axis_raw(joypad, i, a);
|
2014-06-08 17:48:38 +00:00
|
|
|
}
|
|
|
|
|
2015-01-11 05:42:53 +00:00
|
|
|
static bool menu_input_poll_find_trigger_pad(struct menu_bind_state *state,
|
2014-09-03 03:10:34 +00:00
|
|
|
struct menu_bind_state *new_state, unsigned p)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
|
|
|
unsigned a, b, h;
|
2014-09-03 03:10:34 +00:00
|
|
|
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];
|
2014-06-08 17:48:38 +00:00
|
|
|
|
2014-06-09 23:42:26 +00:00
|
|
|
for (b = 0; b < MENU_MAX_BUTTONS; b++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2015-01-11 05:34:32 +00:00
|
|
|
bool iterate = n->buttons[b] && !o->buttons[b];
|
|
|
|
|
|
|
|
if (!iterate)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
state->target->joykey = b;
|
|
|
|
state->target->joyaxis = AXIS_NONE;
|
|
|
|
return true;
|
2014-06-08 17:48:38 +00:00
|
|
|
}
|
|
|
|
|
2014-08-20 14:26:34 +00:00
|
|
|
/* Axes are a bit tricky ... */
|
2014-06-09 23:42:26 +00:00
|
|
|
for (a = 0; a < MENU_MAX_AXES; a++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2015-05-13 01:35:07 +00:00
|
|
|
int locked_distance = abs(n->axes[a] -
|
2014-09-03 03:10:34 +00:00
|
|
|
new_state->axis_state[p].locked_axes[a]);
|
2015-05-13 01:35:07 +00:00
|
|
|
int rested_distance = abs(n->axes[a] -
|
2014-09-03 03:10:34 +00:00
|
|
|
new_state->axis_state[p].rested_axes[a]);
|
2014-06-08 17:48:38 +00:00
|
|
|
|
|
|
|
if (abs(n->axes[a]) >= 20000 &&
|
|
|
|
locked_distance >= 20000 &&
|
2014-08-20 14:26:34 +00:00
|
|
|
rested_distance >= 20000)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2014-08-20 14:26:34 +00:00
|
|
|
/* Take care of case where axis rests on +/- 0x7fff
|
2014-09-02 14:03:17 +00:00
|
|
|
* (e.g. 360 controller on Linux) */
|
2014-06-08 17:48:38 +00:00
|
|
|
state->target->joyaxis = n->axes[a] > 0 ? AXIS_POS(a) : AXIS_NEG(a);
|
|
|
|
state->target->joykey = NO_BTN;
|
|
|
|
|
2014-08-20 14:26:34 +00:00
|
|
|
/* Lock the current axis */
|
2014-06-08 17:48:38 +00:00
|
|
|
new_state->axis_state[p].locked_axes[a] = n->axes[a] > 0 ? 0x7fff : -0x7fff;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-08-20 14:26:34 +00:00
|
|
|
if (locked_distance >= 20000) /* Unlock the axis. */
|
2014-06-08 17:48:38 +00:00
|
|
|
new_state->axis_state[p].locked_axes[a] = 0;
|
|
|
|
}
|
|
|
|
|
2014-06-09 23:42:26 +00:00
|
|
|
for (h = 0; h < MENU_MAX_HATS; h++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
|
|
|
uint16_t trigged = n->hats[h] & (~o->hats[h]);
|
|
|
|
uint16_t sane_trigger = 0;
|
2014-08-20 14:26:34 +00:00
|
|
|
|
2014-06-08 17:48:38 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-05-18 12:57:01 +00:00
|
|
|
static bool menu_input_poll_find_trigger(struct menu_bind_state *state,
|
2014-08-20 14:26:34 +00:00
|
|
|
struct menu_bind_state *new_state)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2015-03-20 19:43:22 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2014-06-08 17:48:38 +00:00
|
|
|
|
|
|
|
if (!state || !new_state)
|
|
|
|
return false;
|
|
|
|
|
2015-03-20 19:43:22 +00:00
|
|
|
for (i = 0; i < settings->input.max_users; i++)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2015-01-11 05:42:53 +00:00
|
|
|
if (!menu_input_poll_find_trigger_pad(state, new_state, i))
|
2015-01-11 05:34:32 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Update the joypad mapping automatically.
|
|
|
|
* More friendly that way. */
|
2015-03-20 19:43:22 +00:00
|
|
|
settings->input.joypad_map[state->user] = i;
|
2015-01-11 05:34:32 +00:00
|
|
|
return true;
|
2014-06-08 17:48:38 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-04-14 11:40:20 +00:00
|
|
|
static bool menu_input_custom_bind_keyboard_cb(void *data, unsigned code)
|
2014-06-08 17:48:38 +00:00
|
|
|
{
|
2014-06-10 00:06:10 +00:00
|
|
|
menu_handle_t *menu = (menu_handle_t*)data;
|
2014-06-08 17:48:38 +00:00
|
|
|
|
2014-06-10 00:06:10 +00:00
|
|
|
if (!menu)
|
2014-06-08 17:48:38 +00:00
|
|
|
return false;
|
|
|
|
|
2014-06-10 00:06:10 +00:00
|
|
|
menu->binds.target->key = (enum retro_key)code;
|
|
|
|
menu->binds.begin++;
|
|
|
|
menu->binds.target++;
|
2014-08-20 14:26:34 +00:00
|
|
|
menu->binds.timeout_end = rarch_get_time_usec() +
|
|
|
|
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
|
|
|
|
|
2015-02-10 22:26:21 +00:00
|
|
|
return (menu->binds.begin <= menu->binds.last);
|
2014-06-08 17:48:38 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
static int menu_input_set_bind_mode_common(rarch_setting_t *setting,
|
2015-04-14 12:04:24 +00:00
|
|
|
enum menu_input_bind_mode type)
|
2015-04-14 11:40:20 +00:00
|
|
|
{
|
2015-05-18 18:53:23 +00:00
|
|
|
menu_displaylist_info_t info = {0};
|
2015-04-14 12:04:24 +00:00
|
|
|
struct retro_keybind *keybind = NULL;
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-05-07 03:31:25 +00:00
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
2015-04-14 11:40:20 +00:00
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
if (!setting)
|
2015-04-14 11:40:20 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-04-14 12:04:24 +00:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case MENU_INPUT_BIND_NONE:
|
|
|
|
return -1;
|
|
|
|
case MENU_INPUT_BIND_SINGLE:
|
|
|
|
keybind = (struct retro_keybind*)setting->value.keybind;
|
|
|
|
|
|
|
|
if (!keybind)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
menu->binds.begin = setting->bind_type;
|
|
|
|
menu->binds.last = setting->bind_type;
|
|
|
|
menu->binds.target = keybind;
|
|
|
|
menu->binds.user = setting->index_offset;
|
2015-05-18 18:53:23 +00:00
|
|
|
|
|
|
|
info.list = menu->menu_list->menu_stack;
|
|
|
|
info.type = MENU_SETTINGS_CUSTOM_BIND_KEYBOARD;
|
|
|
|
info.directory_ptr = nav->selection_ptr;
|
|
|
|
strlcpy(info.label, "custom_bind", sizeof(info.label));
|
|
|
|
|
2015-05-31 20:40:26 +00:00
|
|
|
menu_displaylist_push_list(&info, DISPLAYLIST_INFO);
|
2015-04-14 12:04:24 +00:00
|
|
|
break;
|
|
|
|
case MENU_INPUT_BIND_ALL:
|
|
|
|
menu->binds.target = &settings->input.binds
|
|
|
|
[setting->index_offset][0];
|
|
|
|
menu->binds.begin = MENU_SETTINGS_BIND_BEGIN;
|
|
|
|
menu->binds.last = MENU_SETTINGS_BIND_LAST;
|
2015-05-18 18:53:23 +00:00
|
|
|
|
|
|
|
info.list = menu->menu_list->menu_stack;
|
|
|
|
info.type = MENU_SETTINGS_CUSTOM_BIND_KEYBOARD;
|
|
|
|
info.directory_ptr = nav->selection_ptr;
|
|
|
|
strlcpy(info.label, "custom_bind_all", sizeof(info.label));
|
|
|
|
|
2015-05-31 20:40:26 +00:00
|
|
|
menu_displaylist_push_list(&info, DISPLAYLIST_INFO);
|
2015-04-14 12:04:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-05-17 20:56:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-04-14 12:04:24 +00:00
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
static int menu_input_set_timeout(void)
|
|
|
|
{
|
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-04-14 12:04:24 +00:00
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
menu->binds.timeout_end = rarch_get_time_usec() +
|
2015-04-14 11:40:20 +00:00
|
|
|
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
|
|
|
|
input_keyboard_wait_keys(menu,
|
|
|
|
menu_input_custom_bind_keyboard_cb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
int menu_input_set_keyboard_bind_mode(void *data,
|
2015-04-14 12:04:24 +00:00
|
|
|
enum menu_input_bind_mode type)
|
2015-04-14 11:43:24 +00:00
|
|
|
{
|
2015-04-14 12:04:24 +00:00
|
|
|
rarch_setting_t *setting = (rarch_setting_t*)data;
|
2015-04-14 11:43:24 +00:00
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
if (!setting)
|
|
|
|
return -1;
|
|
|
|
if (menu_input_set_bind_mode_common(setting, type) == -1)
|
2015-04-14 11:43:24 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
return menu_input_set_timeout();
|
|
|
|
}
|
2015-04-14 12:04:24 +00:00
|
|
|
|
2015-05-17 20:56:41 +00:00
|
|
|
int menu_input_set_input_device_bind_mode(void *data,
|
|
|
|
enum menu_input_bind_mode type)
|
|
|
|
{
|
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
rarch_setting_t *setting = (rarch_setting_t*)data;
|
|
|
|
|
|
|
|
if (!setting)
|
|
|
|
return -1;
|
|
|
|
if (menu_input_set_bind_mode_common(setting, type) == -1)
|
|
|
|
return -1;
|
2015-04-14 12:04:24 +00:00
|
|
|
|
2015-04-14 11:43:24 +00:00
|
|
|
menu_input_poll_bind_get_rested_axes(&menu->binds);
|
|
|
|
menu_input_poll_bind_state(&menu->binds);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-18 01:46:15 +00:00
|
|
|
static int menu_input_bind_iterate_keyboard(int64_t current, int timeout)
|
2014-09-24 04:43:42 +00:00
|
|
|
{
|
|
|
|
bool timed_out = false;
|
2015-03-21 22:56:42 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-03-18 18:40:00 +00:00
|
|
|
driver_t *driver = driver_get_ptr();
|
2015-02-13 19:19:20 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return -1;
|
2014-09-24 04:43:42 +00:00
|
|
|
|
|
|
|
if (timeout <= 0)
|
|
|
|
{
|
|
|
|
/* Could be unsafe, but whatever. */
|
|
|
|
menu->binds.target->key = RETROK_UNKNOWN;
|
|
|
|
|
2015-05-18 00:59:37 +00:00
|
|
|
menu->binds.begin++;
|
2014-09-24 04:43:42 +00:00
|
|
|
menu->binds.target++;
|
|
|
|
menu->binds.timeout_end = rarch_get_time_usec() +
|
|
|
|
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
|
|
|
|
timed_out = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* binds.begin is updated in keyboard_press callback. */
|
|
|
|
if (menu->binds.begin > menu->binds.last)
|
|
|
|
{
|
|
|
|
/* Avoid new binds triggering things right away. */
|
2015-03-18 18:40:00 +00:00
|
|
|
driver->flushing_input = true;
|
2014-09-24 04:43:42 +00:00
|
|
|
|
|
|
|
/* We won't be getting any key events, so just cancel early. */
|
|
|
|
if (timed_out)
|
|
|
|
input_keyboard_wait_keys_cancel();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-01-10 05:33:05 +00:00
|
|
|
|
2015-05-18 01:37:07 +00:00
|
|
|
int menu_input_bind_iterate(void)
|
|
|
|
{
|
2015-05-18 01:46:15 +00:00
|
|
|
int64_t current;
|
2015-05-18 01:37:07 +00:00
|
|
|
char msg[PATH_MAX_LENGTH];
|
|
|
|
struct menu_bind_state binds;
|
2015-05-18 01:46:15 +00:00
|
|
|
int timeout = 0;
|
2015-05-18 01:37:07 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
driver_t *driver = driver_get_ptr();
|
|
|
|
global_t *global = global_get_ptr();
|
2015-05-18 01:46:15 +00:00
|
|
|
bool bind_mode_kb = global ? global->menu.bind_mode_keyboard : false;
|
2015-05-18 01:37:07 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return 1;
|
2015-05-18 01:39:47 +00:00
|
|
|
|
|
|
|
menu_driver_render();
|
2015-05-18 01:37:07 +00:00
|
|
|
|
2015-05-18 01:46:15 +00:00
|
|
|
current = rarch_get_time_usec();
|
|
|
|
timeout = (menu->binds.timeout_end - current) / 1000000;
|
2015-05-18 01:37:07 +00:00
|
|
|
|
2015-06-03 22:32:08 +00:00
|
|
|
if (bind_mode_kb)
|
2015-05-18 01:46:15 +00:00
|
|
|
snprintf(msg, sizeof(msg),
|
2015-06-03 22:32:08 +00:00
|
|
|
"[%s]\npress keyboard\n(timeout %d seconds)",
|
2015-05-18 01:37:07 +00:00
|
|
|
input_config_bind_map[
|
2015-05-18 01:46:15 +00:00
|
|
|
menu->binds.begin - MENU_SETTINGS_BIND_BEGIN].desc,
|
|
|
|
timeout);
|
2015-06-03 22:32:08 +00:00
|
|
|
else
|
|
|
|
snprintf(msg, sizeof(msg),
|
|
|
|
"[%s]\npress joypad\n(RETURN to skip)",
|
|
|
|
input_config_bind_map[
|
|
|
|
menu->binds.begin - MENU_SETTINGS_BIND_BEGIN].desc);
|
2015-05-18 01:37:07 +00:00
|
|
|
|
|
|
|
menu_driver_render_messagebox(msg);
|
2015-05-18 01:46:15 +00:00
|
|
|
|
|
|
|
if (bind_mode_kb)
|
|
|
|
return menu_input_bind_iterate_keyboard(current, timeout);
|
|
|
|
|
|
|
|
binds = menu->binds;
|
2015-05-18 01:37:07 +00:00
|
|
|
|
|
|
|
driver->block_input = true;
|
|
|
|
menu_input_poll_bind_state(&binds);
|
|
|
|
|
|
|
|
if ((binds.skip && !menu->binds.skip) ||
|
|
|
|
menu_input_poll_find_trigger(&menu->binds, &binds))
|
|
|
|
{
|
|
|
|
driver->block_input = false;
|
|
|
|
|
|
|
|
/* Avoid new binds triggering things right away. */
|
|
|
|
driver->flushing_input = true;
|
|
|
|
|
|
|
|
binds.begin++;
|
|
|
|
|
|
|
|
if (binds.begin > binds.last)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
binds.target++;
|
|
|
|
}
|
|
|
|
menu->binds = binds;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-03-31 12:38:05 +00:00
|
|
|
static int menu_input_mouse(unsigned *action)
|
|
|
|
{
|
|
|
|
const struct retro_keybind *binds[MAX_USERS];
|
2015-04-13 14:53:01 +00:00
|
|
|
driver_t *driver = driver_get_ptr();
|
2015-03-31 12:38:05 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
video_viewport_t vp;
|
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return -1;
|
|
|
|
|
2015-04-14 14:35:14 +00:00
|
|
|
if (!settings->menu.mouse.enable
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
|| (settings->input.overlay_enable && driver && driver->overlay)
|
|
|
|
#endif
|
|
|
|
)
|
2015-03-31 12:38:05 +00:00
|
|
|
{
|
|
|
|
menu->mouse.left = 0;
|
|
|
|
menu->mouse.right = 0;
|
|
|
|
menu->mouse.wheelup = 0;
|
|
|
|
menu->mouse.wheeldown = 0;
|
|
|
|
menu->mouse.hwheelup = 0;
|
|
|
|
menu->mouse.hwheeldown = 0;
|
|
|
|
menu->mouse.dx = 0;
|
|
|
|
menu->mouse.dy = 0;
|
|
|
|
menu->mouse.x = 0;
|
|
|
|
menu->mouse.y = 0;
|
|
|
|
menu->mouse.screen_x = 0;
|
|
|
|
menu->mouse.screen_y = 0;
|
|
|
|
menu->mouse.scrollup = 0;
|
|
|
|
menu->mouse.scrolldown = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!video_driver_viewport_info(&vp))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (menu->mouse.hwheeldown)
|
|
|
|
{
|
|
|
|
*action = MENU_ACTION_LEFT;
|
|
|
|
menu->mouse.hwheeldown = false;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (menu->mouse.hwheelup)
|
|
|
|
{
|
|
|
|
*action = MENU_ACTION_RIGHT;
|
|
|
|
menu->mouse.hwheelup = false;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
menu->mouse.left = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_LEFT);
|
|
|
|
menu->mouse.right = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_RIGHT);
|
|
|
|
menu->mouse.wheelup = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_WHEELUP);
|
|
|
|
menu->mouse.wheeldown = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_WHEELDOWN);
|
|
|
|
menu->mouse.hwheelup = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELUP);
|
|
|
|
menu->mouse.hwheeldown = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELDOWN);
|
|
|
|
menu->mouse.dx = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_X);
|
|
|
|
menu->mouse.dy = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
|
|
|
|
0, RETRO_DEVICE_ID_MOUSE_Y);
|
|
|
|
|
|
|
|
menu->mouse.screen_x += menu->mouse.dx;
|
|
|
|
menu->mouse.screen_y += menu->mouse.dy;
|
|
|
|
|
|
|
|
menu->mouse.x = ((int)menu->mouse.screen_x * (int)menu->frame_buf.width) / (int)vp.width;
|
|
|
|
menu->mouse.y = ((int)menu->mouse.screen_y * (int)menu->frame_buf.height) / (int)vp.height;
|
|
|
|
|
|
|
|
if (menu->mouse.x < 5)
|
|
|
|
menu->mouse.x = 5;
|
|
|
|
if (menu->mouse.y < 5)
|
|
|
|
menu->mouse.y = 5;
|
|
|
|
if (menu->mouse.x > (int)menu->frame_buf.width - 5)
|
|
|
|
menu->mouse.x = menu->frame_buf.width - 5;
|
|
|
|
if (menu->mouse.y > (int)menu->frame_buf.height - 5)
|
|
|
|
menu->mouse.y = menu->frame_buf.height - 5;
|
|
|
|
|
|
|
|
menu->mouse.scrollup = (menu->mouse.y == 5);
|
|
|
|
menu->mouse.scrolldown = (menu->mouse.y == (int)menu->frame_buf.height - 5);
|
|
|
|
|
|
|
|
if (menu->mouse.dx != 0 || menu->mouse.dy !=0 || menu->mouse.left
|
|
|
|
|| menu->mouse.wheelup || menu->mouse.wheeldown
|
|
|
|
|| menu->mouse.hwheelup || menu->mouse.hwheeldown
|
|
|
|
|| menu->mouse.scrollup || menu->mouse.scrolldown)
|
2015-05-11 16:46:06 +00:00
|
|
|
menu->animation_is_active = true;
|
2015-03-31 12:38:05 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int menu_input_pointer(unsigned *action)
|
|
|
|
{
|
2015-04-04 19:26:11 +00:00
|
|
|
int pointer_device, pointer_x, pointer_y;
|
2015-05-13 01:35:07 +00:00
|
|
|
const struct retro_keybind *binds[MAX_USERS];
|
2015-03-31 12:38:05 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
driver_t *driver = driver_get_ptr();
|
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!settings->menu.pointer.enable)
|
|
|
|
{
|
|
|
|
memset(&menu->pointer, 0, sizeof(menu->pointer));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pointer_device = driver->menu_ctx->set_texture?
|
|
|
|
RETRO_DEVICE_POINTER : RARCH_DEVICE_POINTER_SCREEN;
|
|
|
|
|
|
|
|
menu->pointer.pressed[0] = input_driver_state(binds, 0, pointer_device,
|
|
|
|
0, RETRO_DEVICE_ID_POINTER_PRESSED);
|
|
|
|
menu->pointer.pressed[1] = input_driver_state(binds, 0, pointer_device,
|
|
|
|
1, RETRO_DEVICE_ID_POINTER_PRESSED);
|
|
|
|
menu->pointer.back = input_driver_state(binds, 0, pointer_device,
|
|
|
|
0, RARCH_DEVICE_ID_POINTER_BACK);
|
|
|
|
|
|
|
|
pointer_x = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_X);
|
|
|
|
pointer_y = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_Y);
|
|
|
|
|
2015-04-04 19:26:11 +00:00
|
|
|
menu->pointer.x = ((pointer_x + 0x7fff) * (int)menu->frame_buf.width) / 0xFFFF;
|
|
|
|
menu->pointer.y = ((pointer_y + 0x7fff) * (int)menu->frame_buf.height) / 0xFFFF;
|
2015-03-31 12:38:05 +00:00
|
|
|
|
2015-04-15 12:39:10 +00:00
|
|
|
if (menu->pointer.pressed[0] || menu->pointer.oldpressed[0]
|
|
|
|
|| menu->pointer.back || menu->pointer.dragging
|
2015-04-04 19:26:11 +00:00
|
|
|
|| menu->pointer.dy != 0 || menu->pointer.dx != 0)
|
2015-05-11 16:46:06 +00:00
|
|
|
menu->animation_is_active = true;
|
2015-03-31 12:38:05 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-11 10:03:02 +00:00
|
|
|
static int menu_input_mouse_frame(
|
|
|
|
menu_file_list_cbs_t *cbs, menu_entry_t *entry,
|
|
|
|
uint64_t input_mouse)
|
2015-05-11 09:36:15 +00:00
|
|
|
{
|
2015-05-11 20:36:12 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-05-11 09:36:15 +00:00
|
|
|
menu_list_t *menu_list = menu_list_get_ptr();
|
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
|
|
|
|
2015-05-11 10:03:02 +00:00
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L))
|
|
|
|
{
|
2015-05-14 11:09:06 +00:00
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE))
|
2015-05-17 16:44:50 +00:00
|
|
|
return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_RIGHT);
|
2015-05-11 10:03:02 +00:00
|
|
|
|
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_OK))
|
2015-05-17 16:22:16 +00:00
|
|
|
return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_OK);
|
2015-05-11 20:36:12 +00:00
|
|
|
|
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION))
|
|
|
|
{
|
|
|
|
menu_navigation_set(nav, menu->mouse.ptr, false);
|
|
|
|
}
|
2015-05-11 10:03:02 +00:00
|
|
|
}
|
|
|
|
|
2015-05-11 09:36:15 +00:00
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_R))
|
|
|
|
{
|
|
|
|
menu_list_pop_stack(menu_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_DOWN))
|
|
|
|
{
|
|
|
|
menu_navigation_increment(nav, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_UP))
|
|
|
|
{
|
|
|
|
menu_navigation_decrement(nav, 1);
|
|
|
|
}
|
2015-05-11 10:03:02 +00:00
|
|
|
|
|
|
|
return 0;
|
2015-05-11 09:36:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int menu_input_mouse_post_iterate(uint64_t *input_mouse,
|
2015-06-01 13:25:46 +00:00
|
|
|
menu_file_list_cbs_t *cbs, unsigned action)
|
2015-04-14 05:38:04 +00:00
|
|
|
{
|
|
|
|
driver_t *driver = driver_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
2015-05-07 03:31:25 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-05-11 09:21:23 +00:00
|
|
|
menu_list_t *menu_list = menu_list_get_ptr();
|
2015-05-07 03:31:25 +00:00
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
2015-04-14 05:38:04 +00:00
|
|
|
|
2015-05-11 20:43:16 +00:00
|
|
|
*input_mouse = MOUSE_ACTION_NONE;
|
|
|
|
|
2015-04-14 05:38:04 +00:00
|
|
|
if (!menu)
|
|
|
|
return -1;
|
|
|
|
|
2015-04-14 14:35:14 +00:00
|
|
|
if (!settings->menu.mouse.enable
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
|| (settings->input.overlay_enable && driver && driver->overlay)
|
|
|
|
#endif
|
|
|
|
)
|
2015-04-14 05:38:04 +00:00
|
|
|
{
|
|
|
|
menu->mouse.wheeldown = false;
|
|
|
|
menu->mouse.wheelup = false;
|
|
|
|
menu->mouse.oldleft = false;
|
|
|
|
menu->mouse.oldright = false;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (menu->mouse.left)
|
|
|
|
{
|
|
|
|
if (!menu->mouse.oldleft)
|
|
|
|
{
|
2015-05-11 10:03:02 +00:00
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L);
|
|
|
|
|
2015-05-08 15:19:43 +00:00
|
|
|
rarch_setting_t *setting = menu_setting_find(
|
2015-05-11 09:21:23 +00:00
|
|
|
menu_list->selection_buf->list[nav->selection_ptr].label);
|
2015-04-14 05:38:04 +00:00
|
|
|
menu->mouse.oldleft = true;
|
|
|
|
|
2015-04-20 13:15:55 +00:00
|
|
|
if (menu->mouse.y < menu->header_height)
|
|
|
|
{
|
2015-05-11 09:21:23 +00:00
|
|
|
menu_list_pop_stack(menu_list);
|
2015-04-20 13:15:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-05-07 03:31:25 +00:00
|
|
|
if (menu->mouse.ptr == nav->selection_ptr
|
2015-05-18 13:56:32 +00:00
|
|
|
&& cbs && cbs->action_right && setting &&
|
2015-04-14 05:38:04 +00:00
|
|
|
(setting->type == ST_BOOL || setting->type == ST_UINT || setting->type == ST_FLOAT
|
|
|
|
|| setting->type == ST_STRING))
|
2015-05-11 10:03:02 +00:00
|
|
|
{
|
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE);
|
|
|
|
}
|
|
|
|
else if (menu->mouse.ptr == nav->selection_ptr
|
2015-04-14 05:38:04 +00:00
|
|
|
&& cbs && cbs->action_ok)
|
2015-05-11 10:03:02 +00:00
|
|
|
{
|
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_OK);
|
|
|
|
}
|
2015-05-11 09:21:23 +00:00
|
|
|
else if (menu->mouse.ptr <= menu_list_get_size(menu_list)-1)
|
2015-05-11 20:36:12 +00:00
|
|
|
{
|
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION);
|
|
|
|
}
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
menu->mouse.oldleft = false;
|
|
|
|
|
|
|
|
if (menu->mouse.right)
|
|
|
|
{
|
|
|
|
if (!menu->mouse.oldright)
|
|
|
|
{
|
|
|
|
menu->mouse.oldright = true;
|
2015-05-11 09:36:15 +00:00
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_R);
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
menu->mouse.oldright = false;
|
|
|
|
|
|
|
|
if (menu->mouse.wheeldown)
|
2015-05-11 09:36:15 +00:00
|
|
|
{
|
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_DOWN);
|
|
|
|
}
|
2015-04-14 05:38:04 +00:00
|
|
|
|
|
|
|
if (menu->mouse.wheelup)
|
2015-05-11 09:36:15 +00:00
|
|
|
{
|
|
|
|
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_UP);
|
|
|
|
}
|
2015-04-14 05:38:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-11 09:53:30 +00:00
|
|
|
static int pointer_tap(menu_file_list_cbs_t *cbs,
|
|
|
|
menu_entry_t *entry, unsigned action)
|
2015-04-04 19:26:11 +00:00
|
|
|
{
|
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-05-11 09:21:23 +00:00
|
|
|
menu_list_t *menu_list = menu_list_get_ptr();
|
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
2015-04-04 19:26:11 +00:00
|
|
|
rarch_setting_t *setting =
|
2015-05-08 15:19:43 +00:00
|
|
|
menu_setting_find(
|
2015-05-11 09:21:23 +00:00
|
|
|
menu_list->selection_buf->list[nav->selection_ptr].label);
|
2015-04-04 19:26:11 +00:00
|
|
|
|
2015-05-18 18:00:09 +00:00
|
|
|
if (menu->pointer.ptr == nav->selection_ptr
|
2015-05-18 13:56:32 +00:00
|
|
|
&& cbs && cbs->action_right && setting &&
|
2015-05-08 15:19:43 +00:00
|
|
|
(setting->type == ST_BOOL || setting->type == ST_UINT
|
|
|
|
|| setting->type == ST_FLOAT || setting->type == ST_STRING))
|
2015-05-18 18:00:09 +00:00
|
|
|
return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_RIGHT);
|
|
|
|
else if (menu->pointer.ptr == nav->selection_ptr)
|
|
|
|
return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_OK);
|
2015-04-04 19:26:11 +00:00
|
|
|
else
|
2015-05-18 18:00:09 +00:00
|
|
|
menu_navigation_set(nav, menu->pointer.ptr, false);
|
2015-04-04 19:26:11 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-14 05:38:04 +00:00
|
|
|
static int menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
|
2015-05-11 09:50:55 +00:00
|
|
|
menu_entry_t *entry, unsigned action)
|
2015-04-14 05:38:04 +00:00
|
|
|
{
|
2015-04-04 19:26:11 +00:00
|
|
|
int ret = 0;
|
2015-04-19 10:58:36 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
driver_t *driver = driver_get_ptr();
|
2015-04-04 19:26:11 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2015-04-14 05:38:04 +00:00
|
|
|
|
|
|
|
if (!menu)
|
|
|
|
return -1;
|
|
|
|
|
2015-04-19 10:58:36 +00:00
|
|
|
if (!settings->menu.pointer.enable
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
|| (settings->input.overlay_enable && driver && driver->overlay)
|
|
|
|
#endif
|
|
|
|
)
|
2015-04-14 05:38:04 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (menu->pointer.pressed[0])
|
|
|
|
{
|
2015-04-04 19:26:11 +00:00
|
|
|
if (!menu->pointer.oldpressed[0])
|
2015-04-14 05:38:04 +00:00
|
|
|
{
|
2015-04-04 19:26:11 +00:00
|
|
|
menu->pointer.start_x = menu->pointer.x;
|
|
|
|
menu->pointer.start_y = menu->pointer.y;
|
|
|
|
menu->pointer.old_x = menu->pointer.x;
|
|
|
|
menu->pointer.old_y = menu->pointer.y;
|
2015-04-14 05:38:04 +00:00
|
|
|
menu->pointer.oldpressed[0] = true;
|
2015-04-04 19:26:11 +00:00
|
|
|
}
|
|
|
|
else if (menu->pointer.x != menu->pointer.start_x
|
|
|
|
&& menu->pointer.y != menu->pointer.start_y)
|
|
|
|
{
|
|
|
|
menu->pointer.dragging = true;
|
|
|
|
menu->pointer.dx = menu->pointer.x - menu->pointer.old_x;
|
|
|
|
menu->pointer.dy = menu->pointer.y - menu->pointer.old_y;
|
|
|
|
menu->pointer.old_x = menu->pointer.x;
|
|
|
|
menu->pointer.old_y = menu->pointer.y;
|
|
|
|
}
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (menu->pointer.oldpressed[0])
|
|
|
|
{
|
2015-04-04 19:26:11 +00:00
|
|
|
if (!menu->pointer.dragging)
|
|
|
|
{
|
|
|
|
if (menu->pointer.start_y < menu->header_height)
|
|
|
|
{
|
|
|
|
menu_list_pop_stack(menu->menu_list);
|
|
|
|
}
|
|
|
|
else if (menu->pointer.ptr <= menu_list_get_size(menu->menu_list)-1)
|
|
|
|
{
|
|
|
|
menu->pointer.oldpressed[0] = false;
|
2015-05-11 09:53:30 +00:00
|
|
|
ret = pointer_tap(cbs, entry, action);
|
2015-04-04 19:26:11 +00:00
|
|
|
}
|
|
|
|
}
|
2015-04-14 05:38:04 +00:00
|
|
|
menu->pointer.oldpressed[0] = false;
|
2015-04-04 19:26:11 +00:00
|
|
|
menu->pointer.start_x = 0;
|
|
|
|
menu->pointer.start_y = 0;
|
|
|
|
menu->pointer.old_x = 0;
|
|
|
|
menu->pointer.old_y = 0;
|
|
|
|
menu->pointer.dx = 0;
|
|
|
|
menu->pointer.dy = 0;
|
|
|
|
menu->pointer.dragging = false;
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (menu->pointer.back)
|
|
|
|
{
|
|
|
|
if (!menu->pointer.oldback)
|
|
|
|
{
|
|
|
|
menu->pointer.oldback = true;
|
|
|
|
menu_list_pop_stack(menu->menu_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
menu->pointer.oldback = menu->pointer.back;
|
|
|
|
|
2015-04-04 19:26:11 +00:00
|
|
|
return ret;
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
|
2015-05-11 09:48:43 +00:00
|
|
|
void menu_input_post_iterate(int *ret, unsigned action)
|
2015-04-14 05:38:04 +00:00
|
|
|
{
|
2015-05-11 09:48:43 +00:00
|
|
|
menu_entry_t entry;
|
2015-05-11 20:43:16 +00:00
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
2015-05-11 09:48:43 +00:00
|
|
|
menu_list_t *menu_list = menu_list_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
size_t selected = menu_navigation_get_current_selection();
|
2015-05-17 11:23:27 +00:00
|
|
|
menu_file_list_cbs_t *cbs = menu_list_get_actiondata_at_offset
|
|
|
|
(menu_list->selection_buf, selected);
|
2015-05-11 09:48:43 +00:00
|
|
|
|
|
|
|
menu_entry_get(&entry, selected, NULL, false);
|
2015-04-04 19:26:11 +00:00
|
|
|
|
|
|
|
if (settings->menu.mouse.enable)
|
2015-06-01 13:25:46 +00:00
|
|
|
*ret = menu_input_mouse_post_iterate (&menu->input.mouse, cbs, action);
|
2015-05-11 09:36:15 +00:00
|
|
|
|
2015-05-11 20:43:16 +00:00
|
|
|
*ret = menu_input_mouse_frame(cbs, &entry, menu->input.mouse);
|
2015-05-11 09:36:15 +00:00
|
|
|
|
2015-04-04 19:26:11 +00:00
|
|
|
if (settings->menu.pointer.enable)
|
2015-05-11 09:50:55 +00:00
|
|
|
*ret |= menu_input_pointer_post_iterate(cbs, &entry, action);
|
2015-04-14 05:38:04 +00:00
|
|
|
}
|
|
|
|
|
2015-01-27 00:29:33 +00:00
|
|
|
unsigned menu_input_frame(retro_input_t input, retro_input_t trigger_input)
|
2015-01-10 05:33:05 +00:00
|
|
|
{
|
2015-03-31 12:38:05 +00:00
|
|
|
unsigned ret = 0;
|
2015-01-27 00:29:33 +00:00
|
|
|
static bool initial_held = true;
|
|
|
|
static bool first_held = false;
|
|
|
|
static const retro_input_t input_repeat =
|
|
|
|
(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);
|
2015-05-18 18:00:09 +00:00
|
|
|
menu_navigation_t *nav = menu_navigation_get_ptr();
|
|
|
|
menu_handle_t *menu = menu_driver_get_ptr();
|
|
|
|
driver_t *driver = driver_get_ptr();
|
|
|
|
settings_t *settings = config_get_ptr();
|
2015-02-13 19:19:20 +00:00
|
|
|
|
2015-05-18 18:00:09 +00:00
|
|
|
if (!menu || !driver || !nav)
|
2015-02-13 19:19:20 +00:00
|
|
|
return 0;
|
2015-01-27 00:29:33 +00:00
|
|
|
|
2015-03-18 18:40:00 +00:00
|
|
|
driver->retro_ctx.poll_cb();
|
2015-01-27 00:29:33 +00:00
|
|
|
|
|
|
|
/* don't run anything first frame, only capture held inputs
|
|
|
|
* for old_input_state. */
|
|
|
|
|
|
|
|
if (input & input_repeat)
|
|
|
|
{
|
|
|
|
if (!first_held)
|
|
|
|
{
|
|
|
|
first_held = true;
|
2015-02-13 19:19:20 +00:00
|
|
|
menu->delay.timer = initial_held ? 12 : 6;
|
|
|
|
menu->delay.count = 0;
|
2015-01-27 00:29:33 +00:00
|
|
|
}
|
|
|
|
|
2015-02-13 19:19:20 +00:00
|
|
|
if (menu->delay.count >= menu->delay.timer)
|
2015-01-27 00:29:33 +00:00
|
|
|
{
|
|
|
|
first_held = false;
|
|
|
|
trigger_input |= input & input_repeat;
|
2015-05-18 18:00:09 +00:00
|
|
|
nav->scroll.acceleration =
|
|
|
|
min(nav->scroll.acceleration + 1, 64);
|
2015-01-27 00:29:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
initial_held = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
first_held = false;
|
|
|
|
initial_held = true;
|
2015-05-18 18:00:09 +00:00
|
|
|
nav->scroll.acceleration = 0;
|
2015-01-27 00:29:33 +00:00
|
|
|
}
|
|
|
|
|
2015-03-06 15:00:46 +00:00
|
|
|
menu->delay.count += menu->dt / IDEAL_DT;
|
2015-01-27 00:29:33 +00:00
|
|
|
|
2015-03-18 18:40:00 +00:00
|
|
|
if (driver->block_input)
|
2015-01-27 00:29:33 +00:00
|
|
|
trigger_input = 0;
|
|
|
|
if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_UP))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_UP;
|
|
|
|
else if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN))
|
|
|
|
ret = MENU_ACTION_DOWN;
|
|
|
|
else if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT))
|
|
|
|
ret = MENU_ACTION_LEFT;
|
|
|
|
else if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT))
|
|
|
|
ret = MENU_ACTION_RIGHT;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_scroll_up_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_SCROLL_UP;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_scroll_down_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_SCROLL_DOWN;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_cancel_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_CANCEL;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_ok_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_OK;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_search_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_SEARCH;
|
|
|
|
else if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_Y))
|
2015-05-25 23:10:27 +00:00
|
|
|
ret = MENU_ACTION_SCAN;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_default_btn))
|
2015-03-31 12:38:05 +00:00
|
|
|
ret = MENU_ACTION_START;
|
2015-05-07 01:55:15 +00:00
|
|
|
else if (trigger_input & (1ULL << settings->menu_info_btn))
|
2015-06-01 05:21:00 +00:00
|
|
|
ret = MENU_ACTION_INFO;
|
2015-03-31 12:38:05 +00:00
|
|
|
else if (trigger_input & (1ULL << RARCH_MENU_TOGGLE))
|
|
|
|
ret = MENU_ACTION_TOGGLE;
|
|
|
|
else
|
|
|
|
ret = MENU_ACTION_NOOP;
|
|
|
|
|
2015-04-04 19:26:11 +00:00
|
|
|
if (settings->menu.mouse.enable)
|
|
|
|
menu_input_mouse(&ret);
|
|
|
|
|
|
|
|
if (settings->menu.pointer.enable)
|
|
|
|
menu_input_pointer(&ret);
|
2015-05-19 19:20:46 +00:00
|
|
|
|
|
|
|
if (trigger_input && menu_ctx_driver_get_ptr()->perform_action && menu_ctx_driver_get_ptr()->perform_action(menu->userdata, ret))
|
|
|
|
{
|
|
|
|
return MENU_ACTION_NOOP;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2015-01-10 05:33:05 +00:00
|
|
|
}
|