1 /* RetroArch - A frontend for libretro.
2 * Copyright (C) 2011-2017 - Daniel De Matteis
3 *
4 * RetroArch is free software: you can redistribute it and/or modify it under the terms
5 * of the GNU General Public License as published by the Free Software Found-
6 * ation, either version 3 of the License, or (at your option) any later version.
7 *
8 * RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 * PURPOSE. See the GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License along with RetroArch.
13 * If not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #include <compat/strl.h>
17 #include <file/file_path.h>
18 #include <lists/string_list.h>
19 #include <string/stdstring.h>
20
21 #ifdef HAVE_CONFIG_H
22 #include "../../config.h"
23 #endif
24
25 #include "../menu_driver.h"
26 #include "../menu_entries.h"
27 #include "../menu_cbs.h"
28 #include "../menu_input.h"
29 #include "../menu_setting.h"
30 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
31 #include "../menu_shader.h"
32 #endif
33
34 #include "../../configuration.h"
35 #include "../../core.h"
36 #include "../../core_info.h"
37 #ifdef HAVE_CHEATS
38 #include "../../cheat_manager.h"
39 #endif
40 #include "../../file_path_special.h"
41 #include "../../retroarch.h"
42 #include "../../verbosity.h"
43 #include "../../ui/ui_companion_driver.h"
44 #include "../../network/netplay/netplay.h"
45 #include "../../playlist.h"
46 #include "../../manual_content_scan.h"
47 #include "../misc/cpufreq/cpufreq.h"
48
49 #ifndef BIND_ACTION_RIGHT
50 #define BIND_ACTION_RIGHT(cbs, name) (cbs)->action_right = (name)
51 #endif
52
53 /* Forward declarations */
54 int action_ok_core_lock(const char *path, const char *label, unsigned type, size_t idx, size_t entry_idx);
55
56 extern struct key_desc key_descriptors[RARCH_MAX_KEYS];
57
58 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
generic_shader_action_parameter_right(struct video_shader_parameter * param,unsigned type,const char * label,bool wraparound)59 static int generic_shader_action_parameter_right(struct video_shader_parameter *param,
60 unsigned type, const char *label, bool wraparound)
61 {
62 param->current += param->step;
63 param->current = MIN(MAX(param->minimum, param->current), param->maximum);
64
65 return 0;
66 }
67
generic_shader_action_parameter_right_internal(unsigned type,const char * label,bool wraparound,unsigned offset)68 static int generic_shader_action_parameter_right_internal(unsigned type, const char *label,
69 bool wraparound, unsigned offset)
70 {
71 video_shader_ctx_t shader_info;
72 struct video_shader *shader = menu_shader_get();
73 struct video_shader_parameter *param_menu = NULL;
74 struct video_shader_parameter *param_prev = NULL;
75
76 int ret = 0;
77
78 video_shader_driver_get_current_shader(&shader_info);
79
80 param_prev = &shader_info.data->parameters[type - offset];
81 param_menu = shader ? &shader->parameters [type - offset] : NULL;
82
83 if (!param_prev || !param_menu)
84 return menu_cbs_exit();
85 ret = generic_shader_action_parameter_right(param_prev, type, label, wraparound);
86
87 param_menu->current = param_prev->current;
88 shader->modified = true;
89
90 return ret;
91 }
92
shader_action_parameter_right(unsigned type,const char * label,bool wraparound)93 int shader_action_parameter_right(unsigned type, const char *label, bool wraparound)
94 {
95 return generic_shader_action_parameter_right_internal(type, label, wraparound, MENU_SETTINGS_SHADER_PARAMETER_0);
96 }
97
shader_action_preset_parameter_right(unsigned type,const char * label,bool wraparound)98 int shader_action_preset_parameter_right(unsigned type, const char *label, bool wraparound)
99 {
100 return generic_shader_action_parameter_right_internal(type, label, wraparound, MENU_SETTINGS_SHADER_PRESET_PARAMETER_0);
101 }
102 #endif
103
104 #ifdef HAVE_CHEATS
generic_action_cheat_toggle(size_t idx,unsigned type,const char * label,bool wraparound)105 int generic_action_cheat_toggle(size_t idx, unsigned type, const char *label,
106 bool wraparound)
107 {
108 settings_t *settings = config_get_ptr();
109 bool apply_cheats_after_toggle = settings->bools.apply_cheats_after_toggle;
110
111 cheat_manager_toggle_index(
112 apply_cheats_after_toggle,
113 (unsigned)idx);
114
115 return 0;
116 }
117
action_right_cheat(unsigned type,const char * label,bool wraparound)118 int action_right_cheat(unsigned type, const char *label,
119 bool wraparound)
120 {
121 size_t idx = type - MENU_SETTINGS_CHEAT_BEGIN;
122 return generic_action_cheat_toggle(idx, type, label,
123 wraparound);
124 }
125
action_right_cheat_num_passes(unsigned type,const char * label,bool wraparound)126 static int action_right_cheat_num_passes(unsigned type, const char *label,
127 bool wraparound)
128 {
129 bool refresh = false;
130 unsigned new_size = 0;
131
132 new_size = cheat_manager_get_size() + 1;
133 menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
134 menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
135 cheat_manager_realloc(new_size, CHEAT_HANDLER_TYPE_EMU);
136
137 return 0;
138 }
139
140 #endif
141
action_right_input_desc_kbd(unsigned type,const char * label,bool wraparound)142 static int action_right_input_desc_kbd(unsigned type, const char *label,
143 bool wraparound)
144 {
145 unsigned key_id, user_idx, btn_idx;
146 unsigned remap_id;
147 settings_t *settings = config_get_ptr();
148
149 if (!settings)
150 return 0;
151
152 user_idx = (type - MENU_SETTINGS_INPUT_DESC_KBD_BEGIN) / RARCH_ANALOG_BIND_LIST_END;
153 btn_idx = (type - MENU_SETTINGS_INPUT_DESC_KBD_BEGIN) - RARCH_ANALOG_BIND_LIST_END * user_idx;
154
155 remap_id =
156 settings->uints.input_keymapper_ids[user_idx][btn_idx];
157
158 for (key_id = 0; key_id < RARCH_MAX_KEYS; key_id++)
159 {
160 if (remap_id == key_descriptors[key_id].key)
161 break;
162 }
163
164 if (key_id < (RARCH_MAX_KEYS - 1))
165 key_id++;
166 else
167 key_id = 0;
168
169 settings->uints.input_keymapper_ids[user_idx][btn_idx] = key_descriptors[key_id].key;
170
171 return 0;
172 }
173
174 /* TODO/FIXME: incomplete, lacks error checking */
action_right_input_desc(unsigned type,const char * label,bool wraparound)175 static int action_right_input_desc(unsigned type, const char *label,
176 bool wraparound)
177 {
178 rarch_system_info_t *system = runloop_get_system_info();
179 settings_t *settings = config_get_ptr();
180 unsigned btn_idx;
181 unsigned user_idx;
182 unsigned remap_idx;
183 unsigned bind_idx;
184 unsigned mapped_port;
185
186 if (!settings || !system)
187 return 0;
188
189 user_idx = (type - MENU_SETTINGS_INPUT_DESC_BEGIN) / (RARCH_FIRST_CUSTOM_BIND + 8);
190 btn_idx = (type - MENU_SETTINGS_INPUT_DESC_BEGIN) - (RARCH_FIRST_CUSTOM_BIND + 8) * user_idx;
191 mapped_port = settings->uints.input_remap_ports[user_idx];
192
193 remap_idx = settings->uints.input_remap_ids[user_idx][btn_idx];
194 for (bind_idx = 0; bind_idx < RARCH_ANALOG_BIND_LIST_END; bind_idx++)
195 {
196 if (input_config_bind_order[bind_idx] == remap_idx)
197 break;
198 }
199
200 if (bind_idx < RARCH_CUSTOM_BIND_LIST_END - 1)
201 {
202 if (bind_idx > RARCH_ANALOG_BIND_LIST_END)
203 settings->uints.input_remap_ids[user_idx][btn_idx]++;
204 else
205 {
206 if (bind_idx < RARCH_ANALOG_BIND_LIST_END - 1)
207 {
208 bind_idx++;
209 bind_idx = input_config_bind_order[bind_idx];
210 }
211 else if (bind_idx == RARCH_ANALOG_BIND_LIST_END - 1)
212 bind_idx = RARCH_UNMAPPED;
213 else
214 bind_idx = input_config_bind_order[0];
215 settings->uints.input_remap_ids[user_idx][btn_idx] = bind_idx;
216 }
217 }
218 else if (bind_idx == RARCH_CUSTOM_BIND_LIST_END - 1)
219 settings->uints.input_remap_ids[user_idx][btn_idx] = RARCH_UNMAPPED;
220 else
221 settings->uints.input_remap_ids[user_idx][btn_idx] = input_config_bind_order[0];
222
223 remap_idx = settings->uints.input_remap_ids[user_idx][btn_idx];
224
225 /* skip the not used buttons (unless they are at the end by calling the right desc function recursively
226 also skip all the axes until analog remapping is implemented */
227 if (remap_idx != RARCH_UNMAPPED)
228 {
229 if ((string_is_empty(system->input_desc_btn[mapped_port][remap_idx]) && remap_idx < RARCH_CUSTOM_BIND_LIST_END))
230 action_right_input_desc(type, label, wraparound);
231 }
232
233 return 0;
234 }
235
action_right_scroll(unsigned type,const char * label,bool wraparound)236 static int action_right_scroll(unsigned type, const char *label,
237 bool wraparound)
238 {
239 size_t scroll_accel = 0;
240 unsigned scroll_speed = 0, fast_scroll_speed = 0;
241 size_t selection = menu_navigation_get_selection();
242
243 if (!menu_driver_ctl(MENU_NAVIGATION_CTL_GET_SCROLL_ACCEL, &scroll_accel))
244 return false;
245
246 scroll_speed = (unsigned)((MAX(scroll_accel, 2) - 2) / 4 + 1);
247 fast_scroll_speed = 4 + 4 * scroll_speed;
248
249 if (selection + fast_scroll_speed < (menu_entries_get_size()))
250 {
251 size_t idx = selection + fast_scroll_speed;
252
253 menu_navigation_set_selection(idx);
254 menu_driver_navigation_set(true);
255 }
256 else
257 {
258 if ((menu_entries_get_size() > 0))
259 menu_driver_ctl(MENU_NAVIGATION_CTL_SET_LAST, NULL);
260 }
261
262 return 0;
263 }
264
265 #ifdef HAVE_AUDIOMIXER
audio_mixer_stream_volume_right(unsigned type,const char * label,bool wraparound)266 static int audio_mixer_stream_volume_right(unsigned type, const char *label,
267 bool wraparound)
268 {
269 unsigned offset = (type - MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN);
270 float orig_volume = 0.0f;
271
272 if (offset >= AUDIO_MIXER_MAX_STREAMS)
273 return 0;
274
275 orig_volume = audio_driver_mixer_get_stream_volume(offset);
276 orig_volume = orig_volume + 1.00f;
277
278 audio_driver_mixer_set_stream_volume(offset, orig_volume);
279
280 return 0;
281 }
282 #endif
283
action_right_goto_tab(void)284 static int action_right_goto_tab(void)
285 {
286 menu_ctx_list_t list_info;
287 file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
288
289 list_info.type = MENU_LIST_HORIZONTAL;
290 list_info.action = MENU_ACTION_RIGHT;
291
292 menu_driver_list_cache(&list_info);
293
294 return menu_driver_deferred_push_content_list(selection_buf);
295 }
296
action_right_mainmenu(unsigned type,const char * label,bool wraparound)297 static int action_right_mainmenu(unsigned type, const char *label,
298 bool wraparound)
299 {
300 menu_ctx_list_t list_info;
301 settings_t *settings = config_get_ptr();
302 bool menu_nav_wraparound_enable = settings->bools.menu_navigation_wraparound_enable;
303 const char *menu_ident = menu_driver_ident();
304
305 menu_driver_list_get_selection(&list_info);
306
307 list_info.type = MENU_LIST_PLAIN;
308
309 menu_driver_list_get_size(&list_info);
310
311 /* Tab switching functionality only applies
312 * to XMB */
313 if ((list_info.size == 1) &&
314 string_is_equal(menu_ident, "xmb"))
315 {
316 menu_ctx_list_t list_horiz_info;
317 menu_ctx_list_t list_tabs_info;
318
319 list_horiz_info.type = MENU_LIST_HORIZONTAL;
320 list_tabs_info.type = MENU_LIST_TABS;
321
322 menu_driver_list_get_size(&list_horiz_info);
323 menu_driver_list_get_size(&list_tabs_info);
324
325 if ((list_info.selection != (list_horiz_info.size + list_tabs_info.size))
326 || menu_nav_wraparound_enable)
327 return action_right_goto_tab();
328 }
329 else
330 action_right_scroll(0, "", false);
331
332 return 0;
333 }
334
335 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
action_right_shader_scale_pass(unsigned type,const char * label,bool wraparound)336 static int action_right_shader_scale_pass(unsigned type, const char *label,
337 bool wraparound)
338 {
339 unsigned current_scale, delta;
340 unsigned pass =
341 type - MENU_SETTINGS_SHADER_PASS_SCALE_0;
342 struct video_shader *shader = menu_shader_get();
343 struct video_shader_pass *shader_pass = shader ? &shader->pass[pass] : NULL;
344
345 if (!shader_pass)
346 return menu_cbs_exit();
347
348 current_scale = shader_pass->fbo.scale_x;
349 delta = 1;
350 current_scale = (current_scale + delta) % 6;
351
352 shader_pass->fbo.valid = current_scale;
353 shader_pass->fbo.scale_x = shader_pass->fbo.scale_y = current_scale;
354
355 shader->modified = true;
356
357 return 0;
358 }
359
action_right_shader_filter_pass(unsigned type,const char * label,bool wraparound)360 static int action_right_shader_filter_pass(unsigned type, const char *label,
361 bool wraparound)
362 {
363 unsigned pass = type - MENU_SETTINGS_SHADER_PASS_FILTER_0;
364 unsigned delta = 1;
365 struct video_shader *shader = menu_shader_get();
366 struct video_shader_pass *shader_pass = shader ? &shader->pass[pass] : NULL;
367
368 if (!shader_pass)
369 return menu_cbs_exit();
370
371 shader_pass->filter = ((shader_pass->filter + delta) % 3);
372
373 shader->modified = true;
374
375 return 0;
376 }
377
action_right_shader_filter_default(unsigned type,const char * label,bool wraparound)378 static int action_right_shader_filter_default(unsigned type, const char *label,
379 bool wraparound)
380 {
381 rarch_setting_t *setting = menu_setting_find_enum(MENU_ENUM_LABEL_VIDEO_SMOOTH);
382 if (!setting)
383 return menu_cbs_exit();
384 return menu_action_handle_setting(setting,
385 setting->type, MENU_ACTION_RIGHT,
386 wraparound);
387 }
388
action_right_shader_num_passes(unsigned type,const char * label,bool wraparound)389 static int action_right_shader_num_passes(unsigned type, const char *label,
390 bool wraparound)
391 {
392 bool refresh = false;
393 struct video_shader *shader = menu_shader_get();
394 unsigned pass_count = shader ? shader->passes : 0;
395
396 if (!shader)
397 return menu_cbs_exit();
398
399 if (pass_count < GFX_MAX_SHADERS)
400 shader->passes++;
401
402 menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
403 menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
404 video_shader_resolve_parameters(shader);
405
406 shader->modified = true;
407
408 return 0;
409 }
410 #endif
411
action_right_video_gpu_index(unsigned type,const char * label,bool wraparound)412 static int action_right_video_gpu_index(unsigned type, const char *label,
413 bool wraparound)
414 {
415 enum gfx_ctx_api api = video_context_driver_get_api();
416
417 switch (api)
418 {
419 #ifdef HAVE_VULKAN
420 case GFX_CTX_VULKAN_API:
421 {
422 struct string_list *list = video_driver_get_gpu_api_devices(api);
423
424 if (list)
425 {
426 settings_t *settings = config_get_ptr();
427 if (settings->ints.vulkan_gpu_index <(int)(list->size - 1))
428 settings->ints.vulkan_gpu_index++;
429 else if (settings->ints.vulkan_gpu_index == (int)(list->size - 1))
430 settings->ints.vulkan_gpu_index = 0;
431 }
432
433 break;
434 }
435 #endif
436 #ifdef HAVE_D3D10
437 case GFX_CTX_DIRECT3D10_API:
438 {
439 struct string_list *list = video_driver_get_gpu_api_devices(api);
440
441 if (list)
442 {
443 settings_t *settings = config_get_ptr();
444 if (settings->ints.d3d10_gpu_index < (int)(list->size - 1))
445 settings->ints.d3d10_gpu_index++;
446 else if (settings->ints.d3d10_gpu_index == (int)(list->size - 1))
447 settings->ints.d3d10_gpu_index = 0;
448 }
449
450 break;
451 }
452 #endif
453 #ifdef HAVE_D3D11
454 case GFX_CTX_DIRECT3D11_API:
455 {
456 struct string_list *list = video_driver_get_gpu_api_devices(api);
457
458 if (list)
459 {
460 settings_t *settings = config_get_ptr();
461 if (settings->ints.d3d11_gpu_index < (int)(list->size - 1))
462 settings->ints.d3d11_gpu_index++;
463 else if (settings->ints.d3d11_gpu_index == (int)(list->size - 1))
464 settings->ints.d3d11_gpu_index = 0;
465 }
466
467 break;
468 }
469 #endif
470 #ifdef HAVE_D3D12
471 case GFX_CTX_DIRECT3D12_API:
472 {
473 struct string_list *list = video_driver_get_gpu_api_devices(api);
474
475 if (list)
476 {
477 settings_t *settings = config_get_ptr();
478 if (settings->ints.d3d12_gpu_index < (int)(list->size - 1))
479 settings->ints.d3d12_gpu_index++;
480 else if (settings->ints.d3d12_gpu_index == (int)(list->size - 1))
481 settings->ints.d3d12_gpu_index = 0;
482 }
483
484 break;
485 }
486 #endif
487 default:
488 break;
489 }
490
491 return 0;
492 }
493
action_right_video_resolution(unsigned type,const char * label,bool wraparound)494 static int action_right_video_resolution(unsigned type, const char *label,
495 bool wraparound)
496 {
497 video_driver_get_next_video_out();
498 return 0;
499 }
500
playlist_association_right(unsigned type,const char * label,bool wraparound)501 static int playlist_association_right(unsigned type, const char *label,
502 bool wraparound)
503 {
504 char core_filename[PATH_MAX_LENGTH];
505 size_t i, next, current = 0;
506 core_info_list_t *core_info_list = NULL;
507 core_info_t *core_info = NULL;
508 playlist_t *playlist = playlist_get_cached();
509 const char *default_core_path = playlist_get_default_core_path(playlist);
510 bool default_core_set = false;
511
512 core_filename[0] = '\0';
513
514 if (!playlist)
515 return -1;
516
517 core_info_get_list(&core_info_list);
518 if (!core_info_list)
519 return menu_cbs_exit();
520
521 /* Get current core path association */
522 if (!string_is_empty(default_core_path) &&
523 !string_is_equal(default_core_path, "DETECT"))
524 {
525 const char *default_core_filename = path_basename(default_core_path);
526 if (!string_is_empty(default_core_filename))
527 {
528 strlcpy(core_filename, default_core_filename, sizeof(core_filename));
529 default_core_set = true;
530 }
531 }
532
533 /* Sort cores alphabetically */
534 core_info_qsort(core_info_list, CORE_INFO_LIST_SORT_DISPLAY_NAME);
535
536 /* If a core is currently associated... */
537 if (default_core_set)
538 {
539 /* ...get its index */
540 for (i = 0; i < core_info_list->count; i++)
541 {
542 core_info = NULL;
543 core_info = core_info_get(core_info_list, i);
544 if (!core_info)
545 continue;
546 if (string_starts_with(core_filename, core_info->core_file_id.str))
547 current = i;
548 }
549
550 /* ...then increment it */
551 next = current + 1;
552 if (next >= core_info_list->count)
553 {
554 if (wraparound || (core_info_list->count < 1))
555 {
556 /* Unset core association (DETECT) */
557 next = 0;
558 default_core_set = false;
559 }
560 else
561 next = core_info_list->count - 1;
562 }
563 }
564 /* If a core is *not* currently associated,
565 * select first core in the list */
566 else
567 {
568 next = 0;
569 default_core_set = true;
570 }
571
572 /* If a core is now associated, get new core info */
573 core_info = NULL;
574 if (default_core_set)
575 core_info = core_info_get(core_info_list, next);
576
577 /* Update playlist */
578 playlist_set_default_core_path(playlist, core_info ? core_info->path : "DETECT");
579 playlist_set_default_core_name(playlist, core_info ? core_info->display_name : "DETECT");
580 playlist_write_file(playlist);
581
582 return 0;
583 }
584
playlist_label_display_mode_right(unsigned type,const char * label,bool wraparound)585 static int playlist_label_display_mode_right(unsigned type, const char *label,
586 bool wraparound)
587 {
588 enum playlist_label_display_mode label_display_mode;
589 playlist_t *playlist = playlist_get_cached();
590
591 if (!playlist)
592 return -1;
593
594 label_display_mode = playlist_get_label_display_mode(playlist);
595
596 if (label_display_mode != LABEL_DISPLAY_MODE_KEEP_REGION_AND_DISC_INDEX)
597 label_display_mode = (enum playlist_label_display_mode)((int)label_display_mode + 1);
598 else if (wraparound)
599 label_display_mode = LABEL_DISPLAY_MODE_DEFAULT;
600
601 playlist_set_label_display_mode(playlist, label_display_mode);
602 playlist_write_file(playlist);
603
604 return 0;
605 }
606
playlist_thumbnail_mode_right(playlist_t * playlist,enum playlist_thumbnail_id thumbnail_id,bool wraparound)607 static void playlist_thumbnail_mode_right(playlist_t *playlist, enum playlist_thumbnail_id thumbnail_id,
608 bool wraparound)
609 {
610 enum playlist_thumbnail_mode thumbnail_mode =
611 playlist_get_thumbnail_mode(playlist, thumbnail_id);
612
613 if (thumbnail_mode < PLAYLIST_THUMBNAIL_MODE_BOXARTS)
614 thumbnail_mode = (enum playlist_thumbnail_mode)((unsigned)thumbnail_mode + 1);
615 else if (wraparound)
616 thumbnail_mode = PLAYLIST_THUMBNAIL_MODE_DEFAULT;
617
618 playlist_set_thumbnail_mode(playlist, thumbnail_id, thumbnail_mode);
619 playlist_write_file(playlist);
620 }
621
playlist_right_thumbnail_mode_right(unsigned type,const char * label,bool wraparound)622 static int playlist_right_thumbnail_mode_right(unsigned type, const char *label,
623 bool wraparound)
624 {
625 playlist_t *playlist = playlist_get_cached();
626
627 if (!playlist)
628 return -1;
629
630 playlist_thumbnail_mode_right(playlist, PLAYLIST_THUMBNAIL_RIGHT, wraparound);
631
632 return 0;
633 }
634
playlist_left_thumbnail_mode_right(unsigned type,const char * label,bool wraparound)635 static int playlist_left_thumbnail_mode_right(unsigned type, const char *label,
636 bool wraparound)
637 {
638 playlist_t *playlist = playlist_get_cached();
639
640 if (!playlist)
641 return -1;
642
643 playlist_thumbnail_mode_right(playlist, PLAYLIST_THUMBNAIL_LEFT, wraparound);
644
645 return 0;
646 }
647
playlist_sort_mode_right(unsigned type,const char * label,bool wraparound)648 static int playlist_sort_mode_right(unsigned type, const char *label,
649 bool wraparound)
650 {
651 enum playlist_sort_mode sort_mode;
652 playlist_t *playlist = playlist_get_cached();
653
654 if (!playlist)
655 return -1;
656
657 sort_mode = playlist_get_sort_mode(playlist);
658
659 if (sort_mode < PLAYLIST_SORT_MODE_OFF)
660 sort_mode = (enum playlist_sort_mode)((int)sort_mode + 1);
661 else if (wraparound)
662 sort_mode = PLAYLIST_SORT_MODE_DEFAULT;
663
664 playlist_set_sort_mode(playlist, sort_mode);
665 playlist_write_file(playlist);
666
667 return 0;
668 }
669
manual_content_scan_system_name_right(unsigned type,const char * label,bool wraparound)670 static int manual_content_scan_system_name_right(unsigned type, const char *label,
671 bool wraparound)
672 {
673 settings_t *settings = config_get_ptr();
674 bool show_hidden_files = settings->bools.show_hidden_files;
675 #ifdef HAVE_LIBRETRODB
676 const char *path_content_database = settings->paths.path_content_database;
677 struct string_list *system_name_list =
678 manual_content_scan_get_menu_system_name_list(
679 path_content_database,
680 show_hidden_files);
681 #else
682 struct string_list *system_name_list =
683 manual_content_scan_get_menu_system_name_list(NULL,
684 show_hidden_files);
685 #endif
686 const char *current_system_name = NULL;
687 enum manual_content_scan_system_name_type next_system_name_type =
688 MANUAL_CONTENT_SCAN_SYSTEM_NAME_DATABASE;
689 const char *next_system_name = NULL;
690 unsigned current_index = 0;
691 unsigned next_index = 0;
692 unsigned i;
693
694 if (!system_name_list)
695 return -1;
696
697 /* Get currently selected system name */
698 if (manual_content_scan_get_menu_system_name(¤t_system_name))
699 {
700 /* Get index of currently selected system name */
701 for (i = 0; i < system_name_list->size; i++)
702 {
703 const char *system_name = system_name_list->elems[i].data;
704
705 if (string_is_equal(current_system_name, system_name))
706 {
707 current_index = i;
708 break;
709 }
710 }
711
712 /* Increment index */
713 next_index = current_index + 1;
714 if (next_index >= system_name_list->size)
715 {
716 next_index = 0;
717 if (!wraparound && system_name_list->size > 0)
718 next_index = (unsigned)(system_name_list->size - 1);
719 }
720 }
721
722 /* Get new system name parameters */
723 if (next_index == (unsigned)MANUAL_CONTENT_SCAN_SYSTEM_NAME_CONTENT_DIR)
724 next_system_name_type = MANUAL_CONTENT_SCAN_SYSTEM_NAME_CONTENT_DIR;
725 else if (next_index == (unsigned)MANUAL_CONTENT_SCAN_SYSTEM_NAME_CUSTOM)
726 next_system_name_type = MANUAL_CONTENT_SCAN_SYSTEM_NAME_CUSTOM;
727
728 next_system_name = system_name_list->elems[next_index].data;
729
730 /* Set system name */
731 manual_content_scan_set_menu_system_name(
732 next_system_name_type, next_system_name);
733
734 /* Clean up */
735 string_list_free(system_name_list);
736
737 return 0;
738 }
739
manual_content_scan_core_name_right(unsigned type,const char * label,bool wraparound)740 static int manual_content_scan_core_name_right(unsigned type, const char *label,
741 bool wraparound)
742 {
743 struct string_list *core_name_list =
744 manual_content_scan_get_menu_core_name_list();
745 const char *current_core_name = NULL;
746 enum manual_content_scan_core_type next_core_type =
747 MANUAL_CONTENT_SCAN_CORE_SET;
748 const char *next_core_name = NULL;
749 unsigned current_index = 0;
750 unsigned next_index = 0;
751 unsigned i;
752
753 if (!core_name_list)
754 return -1;
755
756 /* Get currently selected core name */
757 if (manual_content_scan_get_menu_core_name(¤t_core_name))
758 {
759 /* Get index of currently selected core name */
760 for (i = 0; i < core_name_list->size; i++)
761 {
762 const char *core_name = core_name_list->elems[i].data;
763
764 if (string_is_equal(current_core_name, core_name))
765 {
766 current_index = i;
767 break;
768 }
769 }
770
771 /* Increment index */
772 next_index = current_index + 1;
773 if (next_index >= core_name_list->size)
774 {
775 next_index = 0;
776 if (!wraparound && core_name_list->size > 0)
777 next_index = (unsigned)(core_name_list->size - 1);
778 }
779 }
780
781 /* Get new core name parameters */
782 if (next_index == (unsigned)MANUAL_CONTENT_SCAN_CORE_DETECT)
783 next_core_type = MANUAL_CONTENT_SCAN_CORE_DETECT;
784
785 next_core_name = core_name_list->elems[next_index].data;
786
787 /* Set core name */
788 manual_content_scan_set_menu_core_name(
789 next_core_type, next_core_name);
790
791 /* Clean up */
792 string_list_free(core_name_list);
793
794 return 0;
795 }
796
797 #ifndef HAVE_LAKKA_SWITCH
798 #ifdef HAVE_LAKKA
cpu_policy_mode_change(unsigned type,const char * label,bool wraparound)799 static int cpu_policy_mode_change(unsigned type, const char *label,
800 bool wraparound)
801 {
802 bool refresh = false;
803 enum cpu_scaling_mode mode = get_cpu_scaling_mode(NULL);
804 if (mode != CPUSCALING_MANUAL)
805 mode++;
806 set_cpu_scaling_mode(mode, NULL);
807 menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
808 return 0;
809 }
810
cpu_policy_freq_managed_tweak(unsigned type,const char * label,bool wraparound)811 static int cpu_policy_freq_managed_tweak(unsigned type, const char *label,
812 bool wraparound)
813 {
814 bool refresh = false;
815 cpu_scaling_opts_t opts;
816 enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts);
817
818 switch (type) {
819 case MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ:
820 opts.min_freq = get_cpu_scaling_next_frequency_limit(
821 opts.min_freq, 1);
822 set_cpu_scaling_mode(mode, &opts);
823 break;
824 case MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ:
825 opts.max_freq = get_cpu_scaling_next_frequency_limit(
826 opts.max_freq, 1);
827 set_cpu_scaling_mode(mode, &opts);
828 break;
829 };
830
831 return 0;
832 }
833
cpu_policy_freq_managed_gov(unsigned type,const char * label,bool wraparound)834 static int cpu_policy_freq_managed_gov(unsigned type, const char *label,
835 bool wraparound)
836 {
837 int pidx;
838 bool refresh = false;
839 cpu_scaling_opts_t opts;
840 enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts);
841 cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false);
842
843 /* Using drivers[0] governors, should be improved */
844 if (!drivers || !drivers[0])
845 return -1;
846
847 switch (atoi(label)) {
848 case 0:
849 pidx = string_list_find_elem(drivers[0]->available_governors,
850 opts.main_policy);
851 if (pidx && pidx + 1 < drivers[0]->available_governors->size)
852 {
853 strlcpy(opts.main_policy,
854 drivers[0]->available_governors->elems[pidx].data,
855 sizeof(opts.main_policy));
856 set_cpu_scaling_mode(mode, &opts);
857 }
858 break;
859 case 1:
860 pidx = string_list_find_elem(drivers[0]->available_governors,
861 opts.menu_policy);
862 if (pidx && pidx + 1 < drivers[0]->available_governors->size)
863 {
864 strlcpy(opts.menu_policy,
865 drivers[0]->available_governors->elems[pidx].data,
866 sizeof(opts.menu_policy));
867 set_cpu_scaling_mode(mode, &opts);
868 }
869 break;
870 };
871
872 return 0;
873 }
874
cpu_policy_freq_tweak(unsigned type,const char * label,bool wraparound)875 static int cpu_policy_freq_tweak(unsigned type, const char *label,
876 bool wraparound)
877 {
878 bool refresh = false;
879 cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false);
880 unsigned policyid = atoi(label);
881 uint32_t next_freq;
882 if (!drivers)
883 return 0;
884
885 switch (type) {
886 case MENU_SETTINGS_CPU_POLICY_SET_MINFREQ:
887 next_freq = get_cpu_scaling_next_frequency(drivers[policyid],
888 drivers[policyid]->min_policy_freq, 1);
889 set_cpu_scaling_min_frequency(drivers[policyid], next_freq);
890 break;
891 case MENU_SETTINGS_CPU_POLICY_SET_MAXFREQ:
892 next_freq = get_cpu_scaling_next_frequency(drivers[policyid],
893 drivers[policyid]->max_policy_freq, 1);
894 set_cpu_scaling_max_frequency(drivers[policyid], next_freq);
895 break;
896 case MENU_SETTINGS_CPU_POLICY_SET_GOVERNOR:
897 {
898 int pidx = string_list_find_elem(drivers[policyid]->available_governors,
899 drivers[policyid]->scaling_governor);
900 if (pidx && pidx + 1 < drivers[policyid]->available_governors->size)
901 {
902 set_cpu_scaling_governor(drivers[policyid],
903 drivers[policyid]->available_governors->elems[pidx].data);
904 }
905 break;
906 }
907 };
908
909 return 0;
910 }
911 #endif
912 #endif
core_setting_right(unsigned type,const char * label,bool wraparound)913 int core_setting_right(unsigned type, const char *label,
914 bool wraparound)
915 {
916 unsigned idx = type - MENU_SETTINGS_CORE_OPTION_START;
917
918 rarch_ctl(RARCH_CTL_CORE_OPTION_NEXT, &idx);
919
920 return 0;
921 }
922
action_right_core_lock(unsigned type,const char * label,bool wraparound)923 static int action_right_core_lock(unsigned type, const char *label,
924 bool wraparound)
925 {
926 return action_ok_core_lock(label, label, type, 0, 0);
927 }
928
disk_options_disk_idx_right(unsigned type,const char * label,bool wraparound)929 static int disk_options_disk_idx_right(unsigned type, const char *label,
930 bool wraparound)
931 {
932 /* Note: Menu itself provides visual feedback - no
933 * need to print info message to screen */
934 bool print_log = false;
935
936 command_event(CMD_EVENT_DISK_NEXT, &print_log);
937
938 return 0;
939 }
940
bind_right_generic(unsigned type,const char * label,bool wraparound)941 int bind_right_generic(unsigned type, const char *label,
942 bool wraparound)
943 {
944 return menu_setting_set(type, MENU_ACTION_RIGHT, wraparound);
945 }
946
menu_cbs_init_bind_right_compare_type(menu_file_list_cbs_t * cbs,unsigned type,const char * menu_label)947 static int menu_cbs_init_bind_right_compare_type(menu_file_list_cbs_t *cbs,
948 unsigned type, const char *menu_label)
949 {
950 #ifdef HAVE_CHEATS
951 if (type >= MENU_SETTINGS_CHEAT_BEGIN
952 && type <= MENU_SETTINGS_CHEAT_END)
953 {
954 BIND_ACTION_RIGHT(cbs, action_right_cheat);
955 } else
956 #endif
957 #ifdef HAVE_AUDIOMIXER
958 if (type >= MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN
959 && type <= MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_END)
960 {
961 BIND_ACTION_RIGHT(cbs, audio_mixer_stream_volume_right);
962 } else
963 #endif
964 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
965 if (type >= MENU_SETTINGS_SHADER_PARAMETER_0
966 && type <= MENU_SETTINGS_SHADER_PARAMETER_LAST)
967 {
968 BIND_ACTION_RIGHT(cbs, shader_action_parameter_right);
969 }
970 else if (type >= MENU_SETTINGS_SHADER_PRESET_PARAMETER_0
971 && type <= MENU_SETTINGS_SHADER_PRESET_PARAMETER_LAST)
972 {
973 BIND_ACTION_RIGHT(cbs, shader_action_preset_parameter_right);
974 } else
975 #endif
976 if (type >= MENU_SETTINGS_INPUT_DESC_BEGIN
977 && type <= MENU_SETTINGS_INPUT_DESC_END)
978 {
979 BIND_ACTION_RIGHT(cbs, action_right_input_desc);
980 }
981 else if (type >= MENU_SETTINGS_INPUT_DESC_KBD_BEGIN
982 && type <= MENU_SETTINGS_INPUT_DESC_KBD_END)
983 {
984 BIND_ACTION_RIGHT(cbs, action_right_input_desc_kbd);
985 }
986 else if ((type >= MENU_SETTINGS_CORE_OPTION_START) &&
987 (type < MENU_SETTINGS_CHEEVOS_START))
988 {
989 BIND_ACTION_RIGHT(cbs, core_setting_right);
990 }
991 else
992 {
993 switch (type)
994 {
995 case MENU_SETTINGS_CORE_DISK_OPTIONS_DISK_INDEX:
996 BIND_ACTION_RIGHT(cbs, disk_options_disk_idx_right);
997 break;
998 case FILE_TYPE_PLAIN:
999 case FILE_TYPE_DIRECTORY:
1000 case FILE_TYPE_PARENT_DIRECTORY:
1001 case FILE_TYPE_CARCHIVE:
1002 case FILE_TYPE_IN_CARCHIVE:
1003 case FILE_TYPE_CORE:
1004 case FILE_TYPE_RDB:
1005 case FILE_TYPE_RDB_ENTRY:
1006 case FILE_TYPE_RPL_ENTRY:
1007 case FILE_TYPE_CURSOR:
1008 case FILE_TYPE_SHADER:
1009 case FILE_TYPE_SHADER_PRESET:
1010 case FILE_TYPE_IMAGE:
1011 case FILE_TYPE_OVERLAY:
1012 #ifdef HAVE_VIDEO_LAYOUT
1013 case FILE_TYPE_VIDEO_LAYOUT:
1014 #endif
1015 case FILE_TYPE_VIDEOFILTER:
1016 case FILE_TYPE_AUDIOFILTER:
1017 case FILE_TYPE_CONFIG:
1018 case FILE_TYPE_USE_DIRECTORY:
1019 case FILE_TYPE_PLAYLIST_ENTRY:
1020 case MENU_INFO_MESSAGE:
1021 case FILE_TYPE_DOWNLOAD_CORE:
1022 case FILE_TYPE_CHEAT:
1023 case FILE_TYPE_REMAP:
1024 case FILE_TYPE_MOVIE:
1025 case FILE_TYPE_MUSIC:
1026 case FILE_TYPE_IMAGEVIEWER:
1027 case FILE_TYPE_PLAYLIST_COLLECTION:
1028 case FILE_TYPE_DOWNLOAD_CORE_CONTENT:
1029 case FILE_TYPE_DOWNLOAD_THUMBNAIL_CONTENT:
1030 case FILE_TYPE_DOWNLOAD_URL:
1031 case FILE_TYPE_SCAN_DIRECTORY:
1032 case FILE_TYPE_MANUAL_SCAN_DIRECTORY:
1033 case FILE_TYPE_FONT:
1034 case FILE_TYPE_VIDEO_FONT:
1035 case MENU_SETTING_GROUP:
1036 case MENU_SETTINGS_CORE_INFO_NONE:
1037 case MENU_SETTING_ACTION_FAVORITES_DIR:
1038 case MENU_SETTING_ACTION_CORE_MANAGER_OPTIONS:
1039 if (
1040 string_ends_with_size(menu_label, "_tab",
1041 strlen(menu_label), STRLEN_CONST("_tab"))
1042 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
1043 )
1044 {
1045 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1046 break;
1047 }
1048 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1049 break;
1050 case MENU_SETTING_ACTION:
1051 case FILE_TYPE_CONTENTLIST_ENTRY:
1052 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1053 break;
1054 case MENU_SETTING_ACTION_CORE_LOCK:
1055 BIND_ACTION_RIGHT(cbs, action_right_core_lock);
1056 break;
1057 case MENU_SETTING_DROPDOWN_ITEM_INPUT_DESCRIPTION:
1058 case MENU_SETTING_DROPDOWN_ITEM_INPUT_DESCRIPTION_KBD:
1059 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1060 break;
1061 default:
1062 return -1;
1063 }
1064 }
1065
1066 return 0;
1067 }
1068
menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t * cbs,const char * label,const char * menu_label)1069 static int menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t *cbs,
1070 const char *label, const char *menu_label)
1071 {
1072
1073 if (cbs->setting)
1074 {
1075 const char *parent_group = cbs->setting->parent_group;
1076
1077 if (string_is_equal(parent_group, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU))
1078 && (cbs->setting->type == ST_GROUP))
1079 {
1080 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1081 return 0;
1082 }
1083 }
1084
1085 if ( string_starts_with_size(label, "input_player", STRLEN_CONST("input_player")) &&
1086 string_ends_with_size(label, "_joypad_index", strlen(label),
1087 STRLEN_CONST("_joypad_index")))
1088 {
1089 unsigned i;
1090 for (i = 0; i < MAX_USERS; i++)
1091 {
1092 char label_setting[128];
1093 label_setting[0] = '\0';
1094
1095 snprintf(label_setting, sizeof(label_setting), "input_player%d_joypad_index", i + 1);
1096
1097 if (!string_is_equal(label, label_setting))
1098 continue;
1099
1100 BIND_ACTION_RIGHT(cbs, bind_right_generic);
1101 return 0;
1102 }
1103 }
1104
1105 if (string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_PLAYLISTS_TAB)))
1106 {
1107 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1108 return 0;
1109 }
1110
1111 if ( strstr(label, "rdb_entry") ||
1112 string_starts_with_size(label, "content_info", STRLEN_CONST("content_info")))
1113 {
1114 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1115 }
1116 else
1117 {
1118 if (cbs->enum_idx != MSG_UNKNOWN)
1119 {
1120 switch (cbs->enum_idx)
1121 {
1122 case MENU_ENUM_LABEL_SUBSYSTEM_ADD:
1123 case MENU_ENUM_LABEL_SUBSYSTEM_LOAD:
1124 case MENU_ENUM_LABEL_CONNECT_NETPLAY_ROOM:
1125 case MENU_ENUM_LABEL_EXPLORE_ITEM:
1126 case MENU_ENUM_LABEL_NO_SETTINGS_FOUND:
1127 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1128 break;
1129 case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
1130 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
1131 BIND_ACTION_RIGHT(cbs, action_right_shader_scale_pass);
1132 #endif
1133 break;
1134 case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS:
1135 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
1136 BIND_ACTION_RIGHT(cbs, action_right_shader_filter_pass);
1137 #endif
1138 break;
1139 case MENU_ENUM_LABEL_VIDEO_SHADER_DEFAULT_FILTER:
1140 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
1141 BIND_ACTION_RIGHT(cbs, action_right_shader_filter_default);
1142 #endif
1143 break;
1144 case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
1145 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
1146 BIND_ACTION_RIGHT(cbs, action_right_shader_num_passes);
1147 #endif
1148 break;
1149 case MENU_ENUM_LABEL_CHEAT_NUM_PASSES:
1150 #ifdef HAVE_CHEATS
1151 BIND_ACTION_RIGHT(cbs, action_right_cheat_num_passes);
1152 #endif
1153 break;
1154 case MENU_ENUM_LABEL_SCREEN_RESOLUTION:
1155 BIND_ACTION_RIGHT(cbs, action_right_video_resolution);
1156 break;
1157 case MENU_ENUM_LABEL_OPEN_ARCHIVE_DETECT_CORE:
1158 case MENU_ENUM_LABEL_LOAD_ARCHIVE_DETECT_CORE:
1159 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1160 break;
1161 case MENU_ENUM_LABEL_NO_ITEMS:
1162 case MENU_ENUM_LABEL_NO_PLAYLIST_ENTRIES_AVAILABLE:
1163 if (
1164 string_ends_with_size(menu_label, "_tab",
1165 strlen(menu_label),
1166 STRLEN_CONST("_tab")
1167 )
1168 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU))
1169 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
1170 )
1171 {
1172 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1173 }
1174 else
1175 {
1176 BIND_ACTION_RIGHT(cbs, action_right_scroll);
1177 }
1178 break;
1179 case MENU_ENUM_LABEL_START_VIDEO_PROCESSOR:
1180 case MENU_ENUM_LABEL_TAKE_SCREENSHOT:
1181 if (
1182 string_ends_with_size(menu_label, "_tab",
1183 strlen(menu_label),
1184 STRLEN_CONST("_tab"))
1185 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
1186 )
1187 {
1188 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1189 break;
1190 }
1191 case MENU_ENUM_LABEL_VIDEO_GPU_INDEX:
1192 BIND_ACTION_RIGHT(cbs, action_right_video_gpu_index);
1193 break;
1194 case MENU_ENUM_LABEL_PLAYLIST_MANAGER_DEFAULT_CORE:
1195 BIND_ACTION_RIGHT(cbs, playlist_association_right);
1196 break;
1197 case MENU_ENUM_LABEL_PLAYLIST_MANAGER_LABEL_DISPLAY_MODE:
1198 BIND_ACTION_RIGHT(cbs, playlist_label_display_mode_right);
1199 break;
1200 case MENU_ENUM_LABEL_PLAYLIST_MANAGER_RIGHT_THUMBNAIL_MODE:
1201 BIND_ACTION_RIGHT(cbs, playlist_right_thumbnail_mode_right);
1202 break;
1203 case MENU_ENUM_LABEL_PLAYLIST_MANAGER_LEFT_THUMBNAIL_MODE:
1204 BIND_ACTION_RIGHT(cbs, playlist_left_thumbnail_mode_right);
1205 break;
1206 case MENU_ENUM_LABEL_PLAYLIST_MANAGER_SORT_MODE:
1207 BIND_ACTION_RIGHT(cbs, playlist_sort_mode_right);
1208 break;
1209 case MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_SYSTEM_NAME:
1210 BIND_ACTION_RIGHT(cbs, manual_content_scan_system_name_right);
1211 break;
1212 case MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_CORE_NAME:
1213 BIND_ACTION_RIGHT(cbs, manual_content_scan_core_name_right);
1214 break;
1215 #ifndef HAVE_LAKKA_SWITCH
1216 #ifdef HAVE_LAKKA
1217 case MENU_ENUM_LABEL_CPU_PERF_MODE:
1218 BIND_ACTION_RIGHT(cbs, cpu_policy_mode_change);
1219 break;
1220 case MENU_ENUM_LABEL_CPU_POLICY_MAX_FREQ:
1221 case MENU_ENUM_LABEL_CPU_POLICY_MIN_FREQ:
1222 case MENU_ENUM_LABEL_CPU_POLICY_GOVERNOR:
1223 BIND_ACTION_RIGHT(cbs, cpu_policy_freq_tweak);
1224 break;
1225 case MENU_ENUM_LABEL_CPU_MANAGED_MIN_FREQ:
1226 case MENU_ENUM_LABEL_CPU_MANAGED_MAX_FREQ:
1227 BIND_ACTION_RIGHT(cbs, cpu_policy_freq_managed_tweak);
1228 break;
1229 case MENU_ENUM_LABEL_CPU_POLICY_CORE_GOVERNOR:
1230 case MENU_ENUM_LABEL_CPU_POLICY_MENU_GOVERNOR:
1231 BIND_ACTION_RIGHT(cbs, cpu_policy_freq_managed_gov);
1232 break;
1233 #endif
1234 #endif
1235 default:
1236 return -1;
1237 }
1238 }
1239 else
1240 {
1241 return -1;
1242 }
1243 }
1244
1245 return 0;
1246 }
1247
menu_cbs_init_bind_right(menu_file_list_cbs_t * cbs,const char * path,const char * label,unsigned type,size_t idx,const char * menu_label)1248 int menu_cbs_init_bind_right(menu_file_list_cbs_t *cbs,
1249 const char *path, const char *label, unsigned type, size_t idx,
1250 const char *menu_label)
1251 {
1252 if (!cbs)
1253 return menu_cbs_exit();
1254
1255 BIND_ACTION_RIGHT(cbs, bind_right_generic);
1256
1257 if (type == MENU_SETTING_NO_ITEM)
1258 {
1259 if (
1260 string_ends_with_size(menu_label, "_tab",
1261 strlen(menu_label),
1262 STRLEN_CONST("_tab"))
1263 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU))
1264 || string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU))
1265 )
1266 {
1267 BIND_ACTION_RIGHT(cbs, action_right_mainmenu);
1268 return 0;
1269 }
1270 }
1271
1272 if (menu_cbs_init_bind_right_compare_label(cbs, label, menu_label
1273 ) == 0)
1274 return 0;
1275
1276 if (menu_cbs_init_bind_right_compare_type(cbs, type, menu_label ) == 0)
1277 return 0;
1278
1279 return menu_cbs_exit();
1280 }
1281