ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Cleanups - 

* Less string copies
* Some general cleanups
* Add extra param to runloop_message_queue_push so we can pass size_t
of the message
* Consistent conventions for local variable usage for certain things
This commit is contained in:
LibretroAdmin 2024-12-27 15:13:45 +01:00
parent ed58e4a8d8
commit 18c85b5ccd
49 changed files with 1399 additions and 1255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
audio/drivers_microphone/sdl_microphone.c
View File

@ -135,8 +135,9 @@ static void *sdl_microphone_open_mic(void *driver_context,
#if __APPLE__
if (!string_is_equal(audio_driver_get_ident(), "sdl2"))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_SDL2_MIC_NEEDS_SDL2_AUDIO), 1, 100, true, NULL,
const char *msg = msg_hash_to_str(MSG_SDL2_MIC_NEEDS_SDL2_AUDIO),msg_hash_to_str(MSG_SDL2_MIC_NEEDS_SDL2_AUDIO);
runloop_msg_queue_push(msg, strlen(msg),
1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return NULL;
}
@ -155,7 +156,7 @@ static void *sdl_microphone_open_mic(void *driver_context,
/* Only print SDL audio devices if verbose logging is enabled */
if (verbosity_is_enabled())
{
{
int i;
int num_available_microphones = SDL_GetNumAudioDevices(true);
RARCH_DBG("[SDL mic]: %d audio capture devices found:\n", num_available_microphones);

13
bluetooth/drivers/bluetoothctl.c
View File

@ -40,6 +40,7 @@ static void bluetoothctl_free(void *data)
static void bluetoothctl_scan(void *data)
{
char line[512];
const char *msg;
union string_list_elem_attr attr;
FILE *dev_file = NULL;
bluetoothctl_t *btctl = (bluetoothctl_t*) data;
@ -53,7 +54,9 @@ static void bluetoothctl_scan(void *data)
pclose(popen("bluetoothctl --timeout 10 scan on", "r"));
runloop_msg_queue_push(msg_hash_to_str(MSG_BLUETOOTH_SCAN_COMPLETE),
msg = msg_hash_to_str(MSG_BLUETOOTH_SCAN_COMPLETE);
runloop_msg_queue_push(msg, strlen(msg),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
@ -199,6 +202,7 @@ static bool bluetoothctl_connect_device(void *data, unsigned idx)
static bool bluetoothctl_remove_device(void *data, unsigned idx)
{
unsigned i;
const char *msg = NULL;
bluetoothctl_t *btctl = (bluetoothctl_t*) data;
char device[18] = {0};
const char *line = btctl->lines->elems[idx].data;
@ -208,8 +212,7 @@ static bool bluetoothctl_remove_device(void *data, unsigned idx)
* $ bluetoothctl devices
* 'Device (mac address) (device name)'
*/
list = string_split(line, " ");
if (!list)
if (!(list = string_split(line, " ")))
return false;
if (list->size == 0)
@ -227,7 +230,9 @@ static bool bluetoothctl_remove_device(void *data, unsigned idx)
pclose(popen(btctl->command, "r"));
runloop_msg_queue_push(msg_hash_to_str(MSG_BLUETOOTH_PAIRING_REMOVED),
msg = msg_hash_to_str(MSG_BLUETOOTH_PAIRING_REMOVED);
runloop_msg_queue_push(msg, strlen(msg),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);

32
bluetooth/drivers/bluez.c
View File

@ -276,18 +276,18 @@ static int get_default_adapter(bluez_t *bluez, DBusMessage *reply)
do
{
/* empty array? */
if (DBUS_TYPE_INVALID ==
if (DBUS_TYPE_INVALID ==
dbus_message_iter_get_arg_type(&array_2_iter))
continue;
/* a{oa{...}} */
if (DBUS_TYPE_DICT_ENTRY !=
if (DBUS_TYPE_DICT_ENTRY !=
dbus_message_iter_get_arg_type(&array_2_iter))
return 1;
dbus_message_iter_recurse(&array_2_iter, &dict_2_iter);
/* a{oa{s...}} */
if (DBUS_TYPE_STRING !=
if (DBUS_TYPE_STRING !=
dbus_message_iter_get_arg_type(&dict_2_iter))
return 1;
dbus_message_iter_get_basic(&dict_2_iter, &interface_name);
@ -327,14 +327,14 @@ static int read_scanned_devices (bluez_t *bluez, DBusMessage *reply)
do
{
/* a{...} */
if (DBUS_TYPE_DICT_ENTRY !=
if (DBUS_TYPE_DICT_ENTRY !=
dbus_message_iter_get_arg_type(&array_1_iter))
return 1;
dbus_message_iter_recurse(&array_1_iter, &dict_1_iter);
/* a{o...} */
if (DBUS_TYPE_OBJECT_PATH !=
if (DBUS_TYPE_OBJECT_PATH !=
dbus_message_iter_get_arg_type(&dict_1_iter))
return 1;
@ -344,7 +344,7 @@ static int read_scanned_devices (bluez_t *bluez, DBusMessage *reply)
return 1;
/* a{oa} */
if (DBUS_TYPE_ARRAY !=
if (DBUS_TYPE_ARRAY !=
dbus_message_iter_get_arg_type(&dict_1_iter))
return 1;
@ -352,18 +352,18 @@ static int read_scanned_devices (bluez_t *bluez, DBusMessage *reply)
do
{
/* empty array? */
if (DBUS_TYPE_INVALID ==
if (DBUS_TYPE_INVALID ==
dbus_message_iter_get_arg_type(&array_2_iter))
continue;
/* a{oa{...}} */
if (DBUS_TYPE_DICT_ENTRY !=
if (DBUS_TYPE_DICT_ENTRY !=
dbus_message_iter_get_arg_type(&array_2_iter))
return 1;
dbus_message_iter_recurse(&array_2_iter, &dict_2_iter);
/* a{oa{s...}} */
if (DBUS_TYPE_STRING !=
if (DBUS_TYPE_STRING !=
dbus_message_iter_get_arg_type(&dict_2_iter))
return 1;
dbus_message_iter_get_basic(&dict_2_iter, &interface_name);
@ -390,13 +390,13 @@ static int read_scanned_devices (bluez_t *bluez, DBusMessage *reply)
continue;
/* a{oa{sa{...}}} */
if (DBUS_TYPE_DICT_ENTRY !=
if (DBUS_TYPE_DICT_ENTRY !=
dbus_message_iter_get_arg_type(&array_3_iter))
return 1;
dbus_message_iter_recurse(&array_3_iter, &dict_3_iter);
/* a{oa{sa{s...}}} */
if (DBUS_TYPE_STRING !=
if (DBUS_TYPE_STRING !=
dbus_message_iter_get_arg_type(&dict_3_iter))
return 1;
@ -406,7 +406,7 @@ static int read_scanned_devices (bluez_t *bluez, DBusMessage *reply)
if (!dbus_message_iter_next(&dict_3_iter))
return 1;
/* a{oa{sa{sv}}} */
if (DBUS_TYPE_VARIANT !=
if (DBUS_TYPE_VARIANT !=
dbus_message_iter_get_arg_type(&dict_3_iter))
return 1;
@ -606,7 +606,9 @@ static bool bluez_connect_device(void *data, unsigned i)
static bool bluez_remove_device(void *data, unsigned i)
{
bluez_t *bluez = (bluez_t*)data;
const char *msg = NULL;
bluez_t *bluez = (bluez_t*)data;
bluez_dbus_connect(bluez);
/* Disconnect the device */
@ -616,7 +618,9 @@ static bool bluez_remove_device(void *data, unsigned i)
if (device_method(bluez, bluez->devices->data[i].path, "RemoveDevice"))
return false;
runloop_msg_queue_push(msg_hash_to_str(MSG_BLUETOOTH_PAIRING_REMOVED),
msg = msg_hash_to_str(MSG_BLUETOOTH_PAIRING_REMOVED);
runloop_msg_queue_push(msg, strlen(msg),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);

295
camera/camera_driver.c
View File

@ -1,146 +1,149 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2021 - 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/>.
*/
#include <stdint.h>
#include <libretro.h>
#include "../configuration.h"
#include "../driver.h"
#include "../list_special.h"
#include "../runloop.h"
#include "../verbosity.h"
#include "camera_driver.h"
static void *nullcamera_init(const char *device, uint64_t caps,
unsigned width, unsigned height) { return (void*)-1; }
static void nullcamera_free(void *data) { }
static void nullcamera_stop(void *data) { }
static bool nullcamera_start(void *data) { return true; }
static bool nullcamera_poll(void *a,
retro_camera_frame_raw_framebuffer_t b,
retro_camera_frame_opengl_texture_t c) { return true; }
static camera_driver_t camera_null = {
nullcamera_init,
nullcamera_free,
nullcamera_start,
nullcamera_stop,
nullcamera_poll,
"null",
};
const camera_driver_t *camera_drivers[] = {
#ifdef HAVE_V4L2
&camera_v4l2,
#endif
#ifdef EMSCRIPTEN
&camera_rwebcam,
#endif
#ifdef ANDROID
&camera_android,
#endif
&camera_null,
NULL,
};
static camera_driver_state_t camera_driver_st = {0};
camera_driver_state_t *camera_state_get_ptr(void)
{
return &camera_driver_st;
}
/**
* config_get_camera_driver_options:
*
* Get an enumerated list of all camera driver names,
* separated by '|'.
*
* Returns: string listing of all camera driver names,
* separated by '|'.
**/
const char *config_get_camera_driver_options(void)
{
return char_list_new_special(STRING_LIST_CAMERA_DRIVERS, NULL);
}
bool driver_camera_start(void)
{
camera_driver_state_t *camera_st = &camera_driver_st;
if ( camera_st
&& camera_st->data
&& camera_st->driver
&& camera_st->driver->start)
{
settings_t *settings = config_get_ptr();
bool camera_allow = settings->bools.camera_allow;
if (camera_allow)
return camera_st->driver->start(camera_st->data);
runloop_msg_queue_push(
"Camera is explicitly disabled.\n", 1, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return true;
}
void driver_camera_stop(void)
{
camera_driver_state_t *camera_st = &camera_driver_st;
if ( camera_st->driver
&& camera_st->driver->stop
&& camera_st->data)
camera_st->driver->stop(camera_st->data);
}
bool camera_driver_find_driver(const char *prefix,
bool verbosity_enabled)
{
settings_t *settings = config_get_ptr();
camera_driver_state_t
*camera_st = &camera_driver_st;
int i = (int)driver_find_index(
"camera_driver",
settings->arrays.camera_driver);
if (i >= 0)
camera_st->driver = (const camera_driver_t*)camera_drivers[i];
else
{
if (verbosity_enabled)
{
unsigned d;
RARCH_ERR("Couldn't find any %s named \"%s\"\n", prefix,
settings->arrays.camera_driver);
RARCH_LOG_OUTPUT("Available %ss are:\n", prefix);
for (d = 0; camera_drivers[d]; d++)
{
if (camera_drivers[d])
{
RARCH_LOG_OUTPUT("\t%s\n", camera_drivers[d]->ident);
}
}
RARCH_WARN("Going to default to first %s...\n", prefix);
}
if (!(camera_st->driver = (const camera_driver_t*)camera_drivers[0]))
return false;
}
return true;
}
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2021 - 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/>.
*/
#include <stdint.h>
#include <libretro.h>
#include <string/stdstring.h>
#include "../configuration.h"
#include "../driver.h"
#include "../list_special.h"
#include "../runloop.h"
#include "../verbosity.h"
#include "camera_driver.h"
static void *nullcamera_init(const char *device, uint64_t caps,
unsigned width, unsigned height) { return (void*)-1; }
static void nullcamera_free(void *data) { }
static void nullcamera_stop(void *data) { }
static bool nullcamera_start(void *data) { return true; }
static bool nullcamera_poll(void *a,
retro_camera_frame_raw_framebuffer_t b,
retro_camera_frame_opengl_texture_t c) { return true; }
static camera_driver_t camera_null = {
nullcamera_init,
nullcamera_free,
nullcamera_start,
nullcamera_stop,
nullcamera_poll,
"null",
};
const camera_driver_t *camera_drivers[] = {
#ifdef HAVE_V4L2
&camera_v4l2,
#endif
#ifdef EMSCRIPTEN
&camera_rwebcam,
#endif
#ifdef ANDROID
&camera_android,
#endif
&camera_null,
NULL,
};
static camera_driver_state_t camera_driver_st = {0};
camera_driver_state_t *camera_state_get_ptr(void)
{
return &camera_driver_st;
}
/**
* config_get_camera_driver_options:
*
* Get an enumerated list of all camera driver names,
* separated by '|'.
*
* Returns: string listing of all camera driver names,
* separated by '|'.
**/
const char *config_get_camera_driver_options(void)
{
return char_list_new_special(STRING_LIST_CAMERA_DRIVERS, NULL);
}
bool driver_camera_start(void)
{
camera_driver_state_t *camera_st = &camera_driver_st;
if ( camera_st
&& camera_st->data
&& camera_st->driver
&& camera_st->driver->start)
{
settings_t *settings = config_get_ptr();
bool camera_allow = settings->bools.camera_allow;
if (camera_allow)
return camera_st->driver->start(camera_st->data);
runloop_msg_queue_push(
"Camera is explicitly disabled.\n",
STRLEN_CONST("Camera is explicitly disabled.\n"),
1, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return true;
}
void driver_camera_stop(void)
{
camera_driver_state_t *camera_st = &camera_driver_st;
if ( camera_st->driver
&& camera_st->driver->stop
&& camera_st->data)
camera_st->driver->stop(camera_st->data);
}
bool camera_driver_find_driver(const char *prefix,
bool verbosity_enabled)
{
settings_t *settings = config_get_ptr();
camera_driver_state_t
*camera_st = &camera_driver_st;
int i = (int)driver_find_index(
"camera_driver",
settings->arrays.camera_driver);
if (i >= 0)
camera_st->driver = (const camera_driver_t*)camera_drivers[i];
else
{
if (verbosity_enabled)
{
unsigned d;
RARCH_ERR("Couldn't find any %s named \"%s\"\n", prefix,
settings->arrays.camera_driver);
RARCH_LOG_OUTPUT("Available %ss are:\n", prefix);
for (d = 0; camera_drivers[d]; d++)
{
if (camera_drivers[d])
{
RARCH_LOG_OUTPUT("\t%s\n", camera_drivers[d]->ident);
}
}
RARCH_WARN("Going to default to first %s...\n", prefix);
}
if (!(camera_st->driver = (const camera_driver_t*)camera_drivers[0]))
return false;
}
return true;
}

129
cheat_manager.c
View File

@ -68,10 +68,12 @@ unsigned cheat_manager_get_size(void)
#ifdef HAVE_CHEEVOS
static void cheat_manager_pause_cheevos(void)
{
const char *msg = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED_CHEAT);
rcheevos_pause_hardcore();
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED_CHEAT), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED_CHEAT));
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", msg);
}
#endif
@ -104,8 +106,10 @@ void cheat_manager_apply_cheats(void)
if (cheat_st->size > 0 && settings->bools.notification_show_cheats_applied)
{
runloop_msg_queue_push(msg_hash_to_str(MSG_APPLYING_CHEAT), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", msg_hash_to_str(MSG_APPLYING_CHEAT));
const char *_msg = msg_hash_to_str(MSG_APPLYING_CHEAT);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", _msg);
}
#ifdef HAVE_CHEEVOS
@ -604,13 +608,14 @@ bool cheat_manager_realloc(unsigned new_size, unsigned default_handler)
void cheat_manager_update(cheat_manager_t *handle, unsigned handle_idx)
{
size_t _len;
char msg[256];
if (!handle || !handle->cheats || handle->size == 0)
return;
/* TODO/FIXME - localize */
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
"Cheat: #%u [%s]: %s",
handle_idx,
handle->cheats[handle_idx].state
@ -620,7 +625,8 @@ void cheat_manager_update(cheat_manager_t *handle, unsigned handle_idx)
? (handle->cheats[handle_idx].desc)
: (handle->cheats[handle_idx].code)
);
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", msg);
}
@ -848,7 +854,9 @@ int cheat_manager_initialize_memory(rarch_setting_t *setting, size_t idx, bool w
meminfo.id = RETRO_MEMORY_SYSTEM_RAM;
if (!core_get_memory(&meminfo))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_INIT_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_CHEAT_INIT_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -877,6 +885,7 @@ int cheat_manager_initialize_memory(rarch_setting_t *setting, size_t idx, bool w
if (is_search_initialization)
{
const char *msg = NULL;
if (cheat_st->prev_memory_buf)
{
free(cheat_st->prev_memory_buf);
@ -888,7 +897,9 @@ int cheat_manager_initialize_memory(rarch_setting_t *setting, size_t idx, bool w
if (!cheat_st->prev_memory_buf)
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_INIT_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_CHEAT_INIT_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -903,9 +914,11 @@ int cheat_manager_initialize_memory(rarch_setting_t *setting, size_t idx, bool w
if (!cheat_st->matches)
{
const char *_msg = msg_hash_to_str(MSG_CHEAT_INIT_FAIL);
free(cheat_st->prev_memory_buf);
cheat_st->prev_memory_buf = NULL;
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_INIT_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -921,7 +934,9 @@ int cheat_manager_initialize_memory(rarch_setting_t *setting, size_t idx, bool w
offset += cheat_st->memory_size_list[i];
}
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_INIT_SUCCESS), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
msg = msg_hash_to_str(MSG_CHEAT_INIT_SUCCESS);
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
cheat_st->memory_search_initialized = true;
}
@ -1000,6 +1015,7 @@ static void cheat_manager_setup_search_meta(
static int cheat_manager_search(enum cheat_search_type search_type)
{
size_t _len;
char msg[100];
cheat_manager_t *cheat_st = &cheat_manager_state;
unsigned char *curr = cheat_st->curr_memory_buf;
@ -1018,8 +1034,8 @@ static int cheat_manager_search(enum cheat_search_type search_type)
if (cheat_st->num_memory_buffers == 0 || !prev || !cheat_st->matches)
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_NOT_INITIALIZED),
1, 180, true, NULL,
const char *msg = msg_hash_to_str(MSG_CHEAT_SEARCH_NOT_INITIALIZED);
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -1125,10 +1141,9 @@ static int cheat_manager_search(enum cheat_search_type search_type)
offset += cheat_st->memory_size_list[i];
}
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEAT_SEARCH_FOUND_MATCHES), cheat_st->num_matches);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEAT_SEARCH_FOUND_MATCHES), cheat_st->num_matches);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_MENU
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
@ -1209,6 +1224,7 @@ bool cheat_manager_add_new_code(unsigned int memory_search_size, unsigned int ad
int cheat_manager_add_matches(const char *path,
const char *label, unsigned type, size_t menuidx, size_t entry_idx)
{
size_t _len;
char msg[100];
unsigned byte_part = 0;
unsigned int idx = 0;
@ -1225,7 +1241,9 @@ int cheat_manager_add_matches(const char *path,
if (cheat_st->num_matches + cheat_st->size > 100)
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_TOO_MANY), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_TOO_MANY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
cheat_manager_setup_search_meta(cheat_st->search_bit_size, &bytes_per_item, &mask, &bits);
@ -1263,7 +1281,9 @@ int cheat_manager_add_matches(const char *path,
if (!cheat_manager_add_new_code(cheat_st->search_bit_size, idx, (mask << (byte_part * bits)),
cheat_st->big_endian, curr_val))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
}
@ -1276,7 +1296,9 @@ int cheat_manager_add_matches(const char *path,
if (!cheat_manager_add_new_code(cheat_st->search_bit_size, idx, 0xFF,
cheat_st->big_endian, curr_val))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
}
@ -1285,10 +1307,9 @@ int cheat_manager_add_matches(const char *path,
}
}
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_SUCCESS), cheat_st->num_matches);
msg[sizeof(msg) - 1] = 0;
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEAT_SEARCH_ADDED_MATCHES_SUCCESS), cheat_st->num_matches);
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_MENU
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
@ -1677,19 +1698,32 @@ void cheat_manager_match_action(enum cheat_match_action_type match_action, unsig
case CHEAT_MATCH_ACTION_TYPE_COPY:
if (!cheat_manager_add_new_code(cheat_st->search_bit_size, idx, (mask << (byte_part * bits)),
cheat_st->big_endian, curr_val))
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_SUCCESS), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_SUCCESS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return;
case CHEAT_MATCH_ACTION_TYPE_DELETE:
if (bits < 8)
*(cheat_st->matches + idx) = *(cheat_st->matches + idx) &
{
const char *_msg;
if (bits < 8)
*(cheat_st->matches + idx) = *(cheat_st->matches + idx) &
((~(mask << (byte_part * bits))) & 0xFF);
else
memset(cheat_st->matches + idx, 0, bytes_per_item);
if (cheat_st->num_matches > 0)
cheat_st->num_matches--;
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_DELETE_MATCH_SUCCESS), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
else
memset(cheat_st->matches + idx, 0, bytes_per_item);
if (cheat_st->num_matches > 0)
cheat_st->num_matches--;
_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_DELETE_MATCH_SUCCESS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return;
}
return;
@ -1717,20 +1751,33 @@ void cheat_manager_match_action(enum cheat_match_action_type match_action, unsig
case CHEAT_MATCH_ACTION_TYPE_COPY:
if (!cheat_manager_add_new_code(cheat_st->search_bit_size, idx, 0xFF,
cheat_st->big_endian, curr_val))
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_FAIL), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_FAIL);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_SUCCESS), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_ADD_MATCH_SUCCESS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return;
case CHEAT_MATCH_ACTION_TYPE_DELETE:
if (bits < 8)
*(cheat_st->matches + idx) = *(cheat_st->matches + idx) &
{
const char *_msg;
if (bits < 8)
*(cheat_st->matches + idx) = *(cheat_st->matches + idx) &
((~(mask << (byte_part * bits))) & 0xFF);
else
memset(cheat_st->matches + idx, 0, bytes_per_item);
if (cheat_st->num_matches > 0)
cheat_st->num_matches--;
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEAT_SEARCH_DELETE_MATCH_SUCCESS), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
else
memset(cheat_st->matches + idx, 0, bytes_per_item);
if (cheat_st->num_matches > 0)
cheat_st->num_matches--;
_msg = msg_hash_to_str(MSG_CHEAT_SEARCH_DELETE_MATCH_SUCCESS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
}
}
}

166
cheevos/cheevos.c
View File

@ -230,8 +230,7 @@ static void rcheevos_show_mastery_placard(void)
{
const rc_client_game_t* game = rc_client_get_game_info(rcheevos_locals.client);
char title[256];
snprintf(title, sizeof(title),
size_t _len = snprintf(title, sizeof(title),
msg_hash_to_str(rc_client_get_hardcore_enabled(rcheevos_locals.client)
? MSG_CHEEVOS_MASTERED_GAME
: MSG_CHEEVOS_COMPLETED_GAME),
@ -246,9 +245,9 @@ static void rcheevos_show_mastery_placard(void)
const char* displayname = rc_client_get_user_info(rcheevos_locals.client)->display_name;
const bool content_runtime_log = settings->bools.content_runtime_log;
const bool content_runtime_log_aggr = settings->bools.content_runtime_log_aggregate;
size_t len = strlcpy(msg, displayname, sizeof(msg));
size_t __len = strlcpy(msg, displayname, sizeof(msg));
if (len < sizeof(msg) - 12
if (__len < sizeof(msg) - 12
&& (content_runtime_log || content_runtime_log_aggr))
{
const char* content_path = path_get(RARCH_PATH_CONTENT);
@ -265,21 +264,22 @@ static void rcheevos_show_mastery_placard(void)
runtime_log_add_runtime_usec(runtime_log,
runloop_state->core_runtime_usec);
len += strlcpy(msg + len, " | ", sizeof(msg) - len);
runtime_log_get_runtime_str(runtime_log, msg + len, sizeof(msg) - len);
__len += strlcpy(msg + __len, " | ", sizeof(msg) - __len);
runtime_log_get_runtime_str(runtime_log, msg + __len, sizeof(msg) - __len);
msg[sizeof(msg) - 1] = '\0';
free(runtime_log);
}
}
len = strlcpy(badge_name, "i", sizeof(badge_name));
strlcpy(badge_name + len, game->badge_name, sizeof(badge_name) - len);
__len = strlcpy(badge_name, "i", sizeof(badge_name));
strlcpy(badge_name + __len, game->badge_name, sizeof(badge_name) - __len);
gfx_widgets_push_achievement(title, msg, badge_name);
}
else
#endif
runloop_msg_queue_push(title, 0, 3 * 60, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(title, _len, 0, 3 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -321,10 +321,10 @@ static void rcheevos_award_achievement(const rc_client_achievement_t* cheevo)
size_t _len = strlcpy(buffer, msg_hash_to_str(MSG_ACHIEVEMENT_UNLOCKED),
sizeof(buffer));
_len += strlcpy(buffer + _len, ": ", sizeof(buffer) - _len);
strlcpy(buffer + _len, cheevo->title, sizeof(buffer) - _len);
runloop_msg_queue_push(buffer, 0, 2 * 60, false, NULL,
_len += strlcpy(buffer + _len, cheevo->title, sizeof(buffer) - _len);
runloop_msg_queue_push(buffer, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(cheevo->description, 0, 3 * 60, false, NULL,
runloop_msg_queue_push(cheevo->description, strlen(cheevo->description), 0, 3 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -377,24 +377,25 @@ static void rcheevos_lboard_submitted(const rc_client_leaderboard_t* lboard, con
const settings_t* settings = config_get_ptr();
if (lboard && settings->bools.cheevos_visibility_lboard_submit)
{
size_t _len;
char buffer[256];
if (scoreboard)
{
char addendum[64];
const size_t len = snprintf(buffer, sizeof(buffer), msg_hash_to_str(MSG_LEADERBOARD_SUBMISSION),
_len = snprintf(buffer, sizeof(buffer), msg_hash_to_str(MSG_LEADERBOARD_SUBMISSION),
scoreboard->submitted_score, lboard->title);
_len += strlcpy(buffer + _len, " (", sizeof(buffer) - _len);
if (strcmp(scoreboard->best_score, scoreboard->submitted_score) == 0)
snprintf(addendum, sizeof(addendum), msg_hash_to_str(MSG_LEADERBOARD_RANK), scoreboard->new_rank);
_len += snprintf(buffer + _len, sizeof(buffer) - _len,
msg_hash_to_str(MSG_LEADERBOARD_RANK), scoreboard->new_rank);
else
snprintf(addendum, sizeof(addendum), msg_hash_to_str(MSG_LEADERBOARD_BEST), scoreboard->best_score);
snprintf(buffer + len, sizeof(buffer) - len, " (%s)", addendum);
_len += snprintf(buffer + _len, sizeof(buffer) - _len,
msg_hash_to_str(MSG_LEADERBOARD_BEST), scoreboard->best_score);
_len += strlcpy(buffer + _len, ")", sizeof(buffer) - _len);
}
else
{
snprintf(buffer, sizeof(buffer), msg_hash_to_str(MSG_LEADERBOARD_SUBMISSION),
_len = snprintf(buffer, sizeof(buffer), msg_hash_to_str(MSG_LEADERBOARD_SUBMISSION),
lboard->tracker_value, lboard->title);
}
runloop_msg_queue_push(buffer, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(buffer, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -405,9 +406,10 @@ static void rcheevos_lboard_canceled(const rc_client_leaderboard_t* lboard)
if (lboard && settings->bools.cheevos_visibility_lboard_cancel)
{
char buffer[256];
snprintf(buffer, sizeof(buffer), "%s: %s",
msg_hash_to_str(MSG_LEADERBOARD_FAILED), lboard->title);
runloop_msg_queue_push(buffer, 0, 2 * 60, false, NULL,
size_t _len = strlcpy(buffer, msg_hash_to_str(MSG_LEADERBOARD_FAILED), sizeof(buffer));
_len += strlcpy(buffer + _len, ": ", sizeof(buffer) - _len);
_len += strlcpy(buffer + _len, lboard->title, sizeof(buffer) - _len);
runloop_msg_queue_push(buffer, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -423,10 +425,10 @@ static void rcheevos_lboard_started(const rc_client_leaderboard_t* lboard)
_len += strlcpy(buffer + _len, ": ", sizeof(buffer) - _len);
_len += strlcpy(buffer + _len, lboard->title, sizeof(buffer) - _len);
if (lboard->description && *lboard->description)
snprintf(buffer + _len, sizeof(buffer) - _len, "- %s",
_len += snprintf(buffer + _len, sizeof(buffer) - _len, "- %s",
lboard->description);
runloop_msg_queue_push(buffer, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(buffer, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -487,7 +489,7 @@ static void rcheevos_server_error(const char* api_name, const char* message)
size_t _len = strlcpy(buffer, api_name, sizeof(buffer));
_len += strlcpy(buffer + _len, " failed: ", sizeof(buffer) - _len);
_len += strlcpy(buffer + _len, message, sizeof(buffer) - _len);
runloop_msg_queue_push(buffer, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(buffer, _len, 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
}
@ -497,8 +499,8 @@ static void rcheevos_server_disconnected(void)
/* always show message - even with widget. it helps the user understand what the widget is for */
{
const char* message = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_SERVER_DISCONNECTED);
runloop_msg_queue_push(message, 0, 3 * 60, false, NULL,
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_SERVER_DISCONNECTED);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
}
@ -513,8 +515,8 @@ static void rcheevos_server_reconnected(void)
CHEEVOS_LOG(RCHEEVOS_TAG "All pending requests synced to RetroAchievements server\n");
{
const char* message = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_SERVER_RECONNECTED);
runloop_msg_queue_push(message, 0, 3 * 60, false, NULL,
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_SERVER_RECONNECTED);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_SUCCESS);
}
@ -776,10 +778,10 @@ static void rcheevos_toggle_hardcore_active(rcheevos_locals_t* locals)
if (rcheevos_is_game_loaded())
{
const char* msg = msg_hash_to_str(
const char *_msg = msg_hash_to_str(
MSG_CHEEVOS_HARDCORE_MODE_ENABLE);
CHEEVOS_LOG("%s\n", msg);
runloop_msg_queue_push(msg, 0, 3 * 60, true, NULL,
CHEEVOS_LOG("%s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
rcheevos_enforce_hardcore_settings();
@ -878,12 +880,13 @@ void rcheevos_validate_config_settings(void)
* it'll wait for the next vsync event, effectively halfing the fps. the
* auto setting should achieve the most accurate frame rate anyway, so
* disallow any manual values */
if (!settings->bools.video_frame_delay_auto && settings->uints.video_frame_delay != 0) {
if (!settings->bools.video_frame_delay_auto && settings->uints.video_frame_delay != 0)
{
const char* error = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_MANUAL_FRAME_DELAY);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", msg_hash_to_str_us(MSG_CHEEVOS_HARDCORE_PAUSED_MANUAL_FRAME_DELAY));
rcheevos_pause_hardcore();
runloop_msg_queue_push(error, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(error, strlen(error), 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
@ -896,24 +899,26 @@ void rcheevos_validate_config_settings(void)
* allow 1 even though that could be potentially abused on monitors
* running at less than 60Hz because 1 is the default value - many users
* wouldn't know how to change it to auto. */
if (settings->uints.video_swap_interval > 1) {
if (settings->uints.video_swap_interval > 1)
{
const char* error = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_VSYNC_SWAP_INTERVAL);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", msg_hash_to_str_us(MSG_CHEEVOS_HARDCORE_PAUSED_VSYNC_SWAP_INTERVAL));
rcheevos_pause_hardcore();
runloop_msg_queue_push(error, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(error, strlen(error), 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
/* this causes N blank frames to be rendered between real frames, thus
* can slow down the actual number of rendered frames per second. */
if (settings->uints.video_black_frame_insertion > 0) {
if (settings->uints.video_black_frame_insertion > 0)
{
const char* error = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_BLACK_FRAME_INSERTION);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", msg_hash_to_str_us(MSG_CHEEVOS_HARDCORE_PAUSED_BLACK_FRAME_INSERTION));
rcheevos_pause_hardcore();
runloop_msg_queue_push(error, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(error, strlen(error), 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
@ -921,12 +926,13 @@ void rcheevos_validate_config_settings(void)
/* this causes N dupe frames to be rendered between real frames, for
the purposes of shaders that update faster than content. Thus
* can slow down the actual number of rendered frames per second. */
if (settings->uints.video_shader_subframes > 1) {
if (settings->uints.video_shader_subframes > 1)
{
const char* error = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_SHADER_SUBFRAMES);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", msg_hash_to_str_us(MSG_CHEEVOS_HARDCORE_PAUSED_SHADER_SUBFRAMES));
rcheevos_pause_hardcore();
runloop_msg_queue_push(error, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(error, strlen(error), 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
@ -944,14 +950,14 @@ void rcheevos_validate_config_settings(void)
if (!rc_libretro_is_setting_allowed(disallowed_settings, key, val))
{
char buffer[128];
snprintf(buffer, sizeof(buffer),
size_t _len = snprintf(buffer, sizeof(buffer),
msg_hash_to_str_us(MSG_CHEEVOS_HARDCORE_PAUSED_SETTING_NOT_ALLOWED), key, val);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", buffer);
snprintf(buffer, sizeof(buffer),
_len = snprintf(buffer, sizeof(buffer),
msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_SETTING_NOT_ALLOWED), key, val);
rcheevos_pause_hardcore();
runloop_msg_queue_push(buffer, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(buffer, _len, 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
@ -966,13 +972,13 @@ void rcheevos_validate_config_settings(void)
if (console_id && !rc_libretro_is_system_allowed(sysinfo->library_name, console_id))
{
char buffer[256];
snprintf(buffer, sizeof(buffer),
size_t _len = snprintf(buffer, sizeof(buffer),
msg_hash_to_str(MSG_CHEEVOS_HARDCORE_PAUSED_SYSTEM_NOT_FOR_CORE),
rc_console_name(console_id), sysinfo->library_name);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", buffer);
rcheevos_pause_hardcore();
runloop_msg_queue_push(buffer, 0, 4 * 60, false, NULL,
runloop_msg_queue_push(buffer, _len, 0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return;
}
@ -1208,7 +1214,7 @@ static void rc_hash_reset_cdreader_hooks(void)
static void rcheevos_show_game_placard(void)
{
size_t len;
size_t _len;
char msg[256];
rc_client_user_game_summary_t summary;
const settings_t* settings = config_get_ptr();
@ -1221,37 +1227,37 @@ static void rcheevos_show_game_placard(void)
if (summary.num_core_achievements == 0)
{
if (summary.num_unofficial_achievements == 0)
len = snprintf(msg, sizeof(msg), "%s", msg_hash_to_str(MSG_CHEEVOS_GAME_HAS_NO_ACHIEVEMENTS));
_len = snprintf(msg, sizeof(msg), "%s", msg_hash_to_str(MSG_CHEEVOS_GAME_HAS_NO_ACHIEVEMENTS));
else
len = snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_CHEEVOS_UNOFFICIAL_ACHIEVEMENTS_ACTIVATED),
(int)summary.num_unofficial_achievements);
}
else if (rc_client_get_encore_mode_enabled(rcheevos_locals.client))
len = snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_CHEEVOS_ALL_ACHIEVEMENTS_ACTIVATED),
(int)summary.num_core_achievements);
else
len = snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_CHEEVOS_NUMBER_ACHIEVEMENTS_UNLOCKED),
(int)summary.num_unlocked_achievements,
(int)summary.num_core_achievements);
if (summary.num_unsupported_achievements)
{
if (len < sizeof(msg) - 4)
if (_len < sizeof(msg) - 4)
{
msg[len++] = ' ';
msg[len++] = '(';
msg[_len++] = ' ';
msg[_len++] = '(';
len += snprintf(&msg[len], sizeof(msg) - len,
_len += snprintf(&msg[_len], sizeof(msg) - _len,
msg_hash_to_str(MSG_CHEEVOS_UNSUPPORTED_COUNT),
(int)summary.num_unsupported_achievements);
if (len < sizeof(msg) - 1)
if (_len < sizeof(msg) - 1)
{
msg[len++] = ')';
msg[len] = '\0';
msg[_len++] = ')';
msg[_len] = '\0';
}
}
}
@ -1267,14 +1273,14 @@ static void rcheevos_show_game_placard(void)
if (gfx_widgets_ready())
{
char badge_name[32];
size_t _len = strlcpy(badge_name, "i", sizeof(badge_name));
_len += strlcpy(badge_name + _len, game->badge_name,
sizeof(badge_name) - _len);
size_t __len = strlcpy(badge_name, "i", sizeof(badge_name));
__len += strlcpy(badge_name + __len, game->badge_name,
sizeof(badge_name) - __len);
gfx_widgets_push_achievement(game->title, msg, badge_name);
}
else
#endif
runloop_msg_queue_push(msg, 0, 3 * 60, false, NULL,
runloop_msg_queue_push(msg, _len, 0, 3 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -1341,7 +1347,7 @@ static void rcheevos_client_login_callback(int result,
sizeof(msg));
_len += strlcpy(msg + _len, error_message, sizeof(msg) - _len);
CHEEVOS_LOG(RCHEEVOS_TAG "%s\n", msg);
runloop_msg_queue_push(msg, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(msg, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
}
@ -1371,9 +1377,9 @@ static void rcheevos_client_login_callback(int result,
if (settings->bools.cheevos_visibility_account)
{
char msg[128];
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_LOGGED_IN_AS_USER),
size_t _len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_LOGGED_IN_AS_USER),
user->display_name);
runloop_msg_queue_push(msg, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(msg, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -1403,6 +1409,7 @@ static void rcheevos_client_load_game_callback(int result,
if (result != RC_OK || !game)
{
size_t _len;
if (result == RC_NO_GAME_LOADED)
{
CHEEVOS_LOG(RCHEEVOS_TAG "Game not recognized, pausing hardcore\n");
@ -1411,18 +1418,18 @@ static void rcheevos_client_load_game_callback(int result,
if (!settings->bools.cheevos_verbose_enable)
return;
snprintf(msg, sizeof(msg), "%s", msg_hash_to_str(MSG_CHEEVOS_GAME_NOT_IDENTIFIED));
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEEVOS_GAME_NOT_IDENTIFIED), sizeof(msg));
}
else
{
if (!error_message)
error_message = "Unknown error";
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_GAME_LOAD_FAILED), error_message);
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_GAME_LOAD_FAILED), error_message);
CHEEVOS_LOG(RCHEEVOS_TAG "Game load failed: %s\n", error_message);
}
runloop_msg_queue_push(msg, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(msg, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
}
@ -1437,9 +1444,12 @@ static void rcheevos_client_load_game_callback(int result,
CHEEVOS_ERR(RCHEEVOS_TAG "No memory exposed by core\n");
if (settings && settings->bools.cheevos_verbose_enable)
runloop_msg_queue_push(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CANNOT_ACTIVATE_ACHIEVEMENTS_WITH_THIS_CORE),
0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
{
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CANNOT_ACTIVATE_ACHIEVEMENTS_WITH_THIS_CORE);
runloop_msg_queue_push(_msg, strlen(_msg),
0, 4 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
}
rcheevos_unload();
rcheevos_pause_hardcore();
@ -1522,7 +1532,10 @@ bool rcheevos_load(const void *data)
if (string_is_empty(settings->arrays.cheevos_username))
{
CHEEVOS_LOG(RCHEEVOS_TAG "Cannot login (no username)\n");
runloop_msg_queue_push("Missing RetroAchievements account information.", 0, 5 * 60, false, NULL,
runloop_msg_queue_push(
"Missing RetroAchievements account information.",
STRLEN_CONST("Missing RetroAchievements account information."),
0, 5 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
rcheevos_pause_hardcore();
return false;
@ -1612,6 +1625,7 @@ bool rcheevos_load(const void *data)
static void rcheevos_client_change_media_callback(int result,
const char* error_message, rc_client_t* client, void* userdata)
{
size_t _len;
char msg[256];
if (result == RC_OK || result == RC_NO_GAME_LOADED)
@ -1619,7 +1633,7 @@ static void rcheevos_client_change_media_callback(int result,
if (result == RC_HARDCORE_DISABLED)
{
strlcpy(msg, error_message, sizeof(msg));
_len = strlcpy(msg, error_message, sizeof(msg));
rcheevos_hardcore_enabled_changed();
}
else
@ -1627,11 +1641,11 @@ static void rcheevos_client_change_media_callback(int result,
if (!error_message)
error_message = "Unknown error";
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_CHANGE_MEDIA_FAILED), error_message);
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_CHEEVOS_CHANGE_MEDIA_FAILED), error_message);
CHEEVOS_LOG(RCHEEVOS_TAG "Change media failed: %s\n", error_message);
}
runloop_msg_queue_push(msg, 0, 2 * 60, false, NULL,
runloop_msg_queue_push(msg, _len, 0, 2 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}

75
command.c
View File

@ -74,8 +74,10 @@ static void command_post_state_loaded(void)
#ifdef HAVE_CHEEVOS
if (rcheevos_hardcore_active())
{
const char *_msg = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED);
rcheevos_pause_hardcore();
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED), 0, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#endif
#ifdef HAVE_NETWORKING
@ -683,7 +685,7 @@ bool command_network_send(const char *cmd_)
bool command_show_osd_msg(command_t *cmd, const char* arg)
{
runloop_msg_queue_push(arg, 1, 180, false, NULL,
runloop_msg_queue_push(arg, strlen(arg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return true;
}
@ -1060,7 +1062,7 @@ void command_event_set_volume(
audio_driver_mute_enable);
else
#endif
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Audio]: %s\n", msg);
@ -1096,7 +1098,8 @@ void command_event_set_mixer_volume(
msg[++_len] = 'd';
msg[++_len] = 'B';
msg[++_len] = '\0';
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Audio]: %s\n", msg);
@ -1855,6 +1858,7 @@ bool command_event_save_core_config(
const char *dir_menu_config,
const char *rarch_path_config)
{
size_t _len;
char msg[128];
char config_dir[DIR_MAX_LENGTH];
char config_path[PATH_MAX_LENGTH];
@ -1874,8 +1878,10 @@ bool command_event_save_core_config(
if (string_is_empty(config_dir))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CONFIG_DIRECTORY_NOT_SET), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("[Config]: %s\n", msg_hash_to_str(MSG_CONFIG_DIRECTORY_NOT_SET));
const char *_msg = msg_hash_to_str(MSG_CONFIG_DIRECTORY_NOT_SET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("[Config]: %s\n", _msg);
return false;
}
@ -1932,10 +1938,11 @@ bool command_event_save_core_config(
#ifdef HAVE_CONFIGFILE
command_event_save_config(config_path, msg, sizeof(msg));
_len = strlen(msg);
#endif
if (!string_is_empty(msg))
runloop_msg_queue_push(msg, 1, 180, true, NULL,
if (_len > 0)
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
if (overrides_active)
@ -1955,23 +1962,31 @@ void command_event_save_current_config(enum override_type type)
default:
case OVERRIDE_NONE:
{
size_t _len;
char msg[256];
msg[0] = '\0';
if (path_is_empty(RARCH_PATH_CONFIG))
{
strlcpy(msg, "Config directory not set, cannot save configuration.", sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_len = strlcpy(msg, "Config directory not set, cannot save configuration.", sizeof(msg));
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
{
if (runloop_st->flags & RUNLOOP_FLAG_OVERRIDES_ACTIVE)
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ACTIVE_NOT_SAVING), sizeof(msg));
{
_len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ACTIVE_NOT_SAVING), sizeof(msg));
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
{
command_event_save_config(path_get(RARCH_PATH_CONFIG), msg, sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
}
break;
@ -1979,28 +1994,31 @@ void command_event_save_current_config(enum override_type type)
case OVERRIDE_CORE:
case OVERRIDE_CONTENT_DIR:
{
size_t _len;
char msg[256];
int8_t ret = config_save_overrides(type, &runloop_st->system, false, NULL);
switch (ret)
{
case 1:
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_SAVED_SUCCESSFULLY), sizeof(msg));
_len = strlcpy(msg,
msg_hash_to_str(MSG_OVERRIDES_SAVED_SUCCESSFULLY), sizeof(msg));
/* set overrides to active so the original config can be
restored after closing content */
runloop_st->flags |= RUNLOOP_FLAG_OVERRIDES_ACTIVE;
break;
case -1:
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_NOT_SAVED), sizeof(msg));
_len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_NOT_SAVED), sizeof(msg));
break;
default:
case 0:
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_SAVING), sizeof(msg));
_len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_SAVING), sizeof(msg));
break;
}
RARCH_LOG("[Overrides]: %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_MENU
{
@ -2027,14 +2045,15 @@ void command_event_remove_current_config(enum override_type type)
case OVERRIDE_CORE:
case OVERRIDE_CONTENT_DIR:
{
size_t _len;
char msg[256];
if (config_save_overrides(type, &runloop_st->system, true, NULL))
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_REMOVED_SUCCESSFULLY), sizeof(msg));
_len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_REMOVED_SUCCESSFULLY), sizeof(msg));
else
strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_REMOVING), sizeof(msg));
_len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_REMOVING), sizeof(msg));
RARCH_LOG("[Overrides]: %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_MENU
{
@ -2053,10 +2072,10 @@ bool command_event_main_state(unsigned cmd)
{
char msg[128];
char state_path[16384];
size_t _len = 0;
settings_t *settings = config_get_ptr();
bool savestates_enabled = core_info_current_supports_savestate();
bool ret = false;
bool push_msg = true;
state_path[0] = msg[0] = '\0';
@ -2107,7 +2126,6 @@ bool command_event_main_state(unsigned cmd)
video_st->frame_time_count = 0;
ret = true;
push_msg = false;
}
break;
case CMD_EVENT_LOAD_STATE:
@ -2125,7 +2143,6 @@ bool command_event_main_state(unsigned cmd)
ret = true;
}
}
push_msg = false;
break;
case CMD_EVENT_UNDO_LOAD_STATE:
{
@ -2144,25 +2161,27 @@ bool command_event_main_state(unsigned cmd)
}
#endif
command_event_undo_load_state(msg, sizeof(msg));
_len = strlen(msg);
ret = true;
break;
}
case CMD_EVENT_UNDO_SAVE_STATE:
command_event_undo_save_state(msg, sizeof(msg));
_len = strlen(msg);
ret = true;
break;
}
}
else
strlcpy(msg, msg_hash_to_str(
_len = strlcpy(msg, msg_hash_to_str(
MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES), sizeof(msg));
if (push_msg)
runloop_msg_queue_push(msg, 2, 180, true, NULL,
if (_len > 0)
{
runloop_msg_queue_push(msg, _len, 2, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
if (!string_is_empty(msg))
RARCH_LOG("[State]: %s\n", msg);
}
return ret;
}

30
configuration.c
View File

@ -4467,9 +4467,11 @@ bool config_load_override(void *data)
if (settings->bools.notification_show_config_override_load
&& show_notification)
runloop_msg_queue_push(msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED),
1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
/* Reset save paths. */
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
@ -4521,9 +4523,11 @@ bool config_load_override_file(const char *config_path)
if (settings->bools.notification_show_config_override_load
&& show_notification)
runloop_msg_queue_push(msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED),
1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
/* Reset save paths. */
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
@ -4729,9 +4733,11 @@ bool config_load_remap(const char *directory_input_remapping,
success:
if (notification_show_remap_load)
runloop_msg_queue_push(
msg_hash_to_str(msg_remap_loaded), 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(msg_remap_loaded);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return true;
}
@ -6384,7 +6390,7 @@ void input_config_parse_mouse_button(
fill_pathname_join_delim(key, s, "mbtn", '_', sizeof(key));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
if (config_get_array(conf, key, tmp, sizeof(tmp)) > 0)
{
bind->mbutton = NO_BTN;
@ -6455,7 +6461,7 @@ void input_config_parse_joy_axis(
fill_pathname_join_delim(key_label, s,
"axis_label", '_', sizeof(key_label));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
if (config_get_array(conf, key, tmp, sizeof(tmp)) > 0)
{
if ( tmp[0] == 'n'
&& tmp[1] == 'u'
@ -6546,7 +6552,7 @@ void input_config_parse_joy_button(
fill_pathname_join_delim(key_label, s,
"btn_label", '_', sizeof(key_label));
if (config_get_array(conf, key, tmp, sizeof(tmp)))
if (config_get_array(conf, key, tmp, sizeof(tmp)) > 0)
{
btn = tmp;
if ( btn[0] == 'n'

39
disk_control_interface.c
View File

@ -338,15 +338,14 @@ bool disk_control_set_eject_state(
{
bool error = false;
char msg[128];
msg[0] = '\0';
size_t _len;
if (!disk_control || !disk_control->cb.set_eject_state)
return false;
/* Set eject state */
if (disk_control->cb.set_eject_state(eject))
strlcpy(
_len = strlcpy(
msg,
eject
? msg_hash_to_str(MSG_DISK_EJECTED)
@ -355,7 +354,7 @@ bool disk_control_set_eject_state(
else
{
error = true;
strlcpy(
_len = strlcpy(
msg,
eject
? msg_hash_to_str(MSG_VIRTUAL_DISK_TRAY_EJECT)
@ -363,7 +362,7 @@ bool disk_control_set_eject_state(
sizeof(msg));
}
if (!string_is_empty(msg))
if (_len > 0)
{
if (error)
RARCH_ERR("[Disc]: %s\n", msg);
@ -373,8 +372,7 @@ bool disk_control_set_eject_state(
/* Errors should always be displayed */
if (verbosity || error)
runloop_msg_queue_push(
msg, 1, error ? 180 : 60,
true, NULL,
msg, _len, 1, error ? 180 : 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -446,11 +444,8 @@ bool disk_control_set_index(
/* Errors should always be displayed */
if (verbosity || error)
runloop_msg_queue_push(
msg, 1, msg_duration,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, strlen(msg), 1, msg_duration, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
/* If operation was successful, update disk
@ -634,13 +629,13 @@ bool disk_control_append_image(
msg[ _len] = ':';
msg[++_len] = ' ';
msg[++_len] = '\0';
strlcpy(msg + _len, image_filename, sizeof(msg) - _len);
_len += strlcpy(msg + _len, image_filename, sizeof(msg) - _len);
RARCH_LOG("[Disc]: %s\n", msg);
/* This message should always be displayed, since
* the menu itself does not provide sufficient
* visual feedback */
runloop_msg_queue_push(msg, 0, 120, true, NULL,
runloop_msg_queue_push(msg, _len, 0, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return true;
@ -664,11 +659,9 @@ error:
msg[ _len] = ':';
msg[++_len] = ' ';
msg[++_len] = '\0';
strlcpy(msg + _len, image_filename, sizeof(msg) - _len);
_len += strlcpy(msg + _len, image_filename, sizeof(msg) - _len);
runloop_msg_queue_push(
msg, 0, 180,
true, NULL,
runloop_msg_queue_push(msg, _len, 0, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
@ -806,6 +799,7 @@ bool disk_control_verify_initial_index(
/* If current disk is incorrect, notify user */
if (!success && enabled)
{
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_SET_INITIAL_DISK);
RARCH_ERR(
"[Disc]: Failed to set initial disc index:\n> Expected"
" [%u] %s\n> Detected [%u] %s\n",
@ -816,10 +810,7 @@ bool disk_control_verify_initial_index(
/* Ignore 'verbosity' setting - errors should
* always be displayed */
runloop_msg_queue_push(
msg_hash_to_str(MSG_FAILED_TO_SET_INITIAL_DISK),
0, 60,
true, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 0, 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* Since a failure here typically means that the
@ -861,9 +852,7 @@ bool disk_control_verify_initial_index(
* we do not want to 'overwrite' them */
if (verbosity)
runloop_msg_queue_push(
msg,
0, msg_duration,
false, NULL,
msg, strlen(msg), 0, msg_duration, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_CHEEVOS

31
gfx/gfx_widgets.c
View File

@ -179,6 +179,7 @@ static void msg_widget_msg_transition_animation_done(void *userdata)
void gfx_widgets_msg_queue_push(
retro_task_t *task,
const char *msg,
size_t len,
unsigned duration,
char *title,
enum message_queue_icon icon,
@ -203,7 +204,6 @@ void gfx_widgets_msg_queue_push(
if (!msg_widget)
{
const char *title = msg;
size_t title_length = strlen(title);
msg_widget = (disp_widget_msg_t*)malloc(sizeof(*msg_widget));
@ -245,8 +245,7 @@ void gfx_widgets_msg_queue_push(
{
title = msg_widget->msg = strdup(task->title);
msg_widget->msg_new = strdup(title);
title_length = strlen(title);
msg_widget->msg_len = title_length;
msg_widget->msg_len = len;
if (!string_is_empty(task->error))
msg_widget->flags |= DISPWIDG_FLAG_TASK_ERROR;
@ -288,11 +287,11 @@ void gfx_widgets_msg_queue_push(
unsigned text_width = font_driver_get_message_width(
p_dispwidget->gfx_widget_fonts.msg_queue.font,
title,
title_length,
len,
1.0f);
msg_widget->text_height = p_dispwidget->gfx_widget_fonts.msg_queue.line_height;
/* 1 byte uses for inserting '\n' */
msg_len = title_length + 1 + 1;
msg_len = len + 1 + 1;
if (!(msg = (char *)malloc(msg_len)))
return;
msg[0] = '\0';
@ -308,24 +307,22 @@ void gfx_widgets_msg_queue_push(
if ((text_width - (text_width >> 2)) < width)
width = text_width - (text_width >> 2);
word_wrap(msg, msg_len, title, title_length,
(int)((title_length * width) / text_width),
word_wrap(msg, msg_len, title, len,
(int)((len * width) / text_width),
100, 2);
/* Recalculate widget width with longest wrapped line */
wrap_length = string_index_last_occurance(msg, '\n');
if (wrap_length)
{
title_length -= wrap_length;
len -= wrap_length;
if (title_length < wrap_length)
title_length = wrap_length;
if (len < wrap_length)
len = wrap_length;
text_width = font_driver_get_message_width(
p_dispwidget->gfx_widget_fonts.msg_queue.font,
title,
title_length,
1.0f);
title, len, 1.0f);
width = text_width;
}
@ -358,7 +355,7 @@ void gfx_widgets_msg_queue_push(
if (!string_is_equal(task->title, msg_widget->msg_new))
{
size_t len;
size_t _len;
unsigned new_width;
if (msg_widget->msg_new)
@ -369,14 +366,14 @@ void gfx_widgets_msg_queue_push(
title = msg_widget->msg_new = strdup(task->title);
len = strlen(title);
_len = strlen(title);
new_width = font_driver_get_message_width(
p_dispwidget->gfx_widget_fonts.msg_queue.font,
title,
len,
_len,
1.0f);
msg_widget->msg_len = len;
msg_widget->msg_len = _len;
msg_widget->msg_transition_animation = 0;
if (!((task->flags & RETRO_TASK_FLG_ALTERNATIVE_LOOK) > 0))

1
gfx/gfx_widgets.h
View File

@ -351,6 +351,7 @@ void gfx_widgets_deinit(bool widgets_persisting);
void gfx_widgets_msg_queue_push(
retro_task_t *task, const char *msg,
size_t len,
unsigned duration,
char *title,
enum message_queue_icon icon,

16
gfx/video_driver.c
View File

@ -795,6 +795,7 @@ static void video_monitor_compute_fps_statistics(uint64_t
void video_monitor_set_refresh_rate(float hz)
{
size_t _len;
char msg[256];
char rate[8];
settings_t *settings = config_get_ptr();
@ -804,13 +805,13 @@ void video_monitor_set_refresh_rate(float hz)
return;
snprintf(rate, sizeof(rate), "%.3f", hz);
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_VIDEO_REFRESH_RATE_CHANGED), rate);
/* Message is visible for twice the usual duration */
/* as modeswitch will cause monitors to go blank for a while */
if (settings->bools.notification_show_refresh_rate)
runloop_msg_queue_push(msg, 1, 360, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 360, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Video]: %s\n", msg);
@ -1070,12 +1071,11 @@ void recording_dump_frame(
if ( (vp.width != record_st->gpu_width)
|| (vp.height != record_st->gpu_height))
{
const char *recording_failed_str =
const char *_msg =
msg_hash_to_str(MSG_RECORDING_TERMINATED_DUE_TO_RESIZE);
RARCH_WARN("[Recording]: %s\n", recording_failed_str);
RARCH_WARN("[Recording]: %s\n", _msg);
runloop_msg_queue_push(recording_failed_str,
1, 180, true,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
command_event(CMD_EVENT_RECORD_DEINIT, NULL);
return;
@ -4041,6 +4041,7 @@ void video_driver_frame(const void *data, unsigned width,
gfx_widgets_msg_queue_push(
NULL,
msg_entry.msg,
strlen(msg_entry.msg),
roundf((float)msg_entry.duration / 60.0f * 1000.0f),
msg_entry.title,
msg_entry.icon,
@ -4253,7 +4254,8 @@ void video_driver_frame(const void *data, unsigned width,
else
#endif
{
runloop_msg_queue_push(status_text, 2, 1, true, NULL,
/* TODO/FIXME - get rid of strlen here */
runloop_msg_queue_push(status_text, strlen(status_text), 2, 1, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}

2
gfx/video_filter.c
View File

@ -142,7 +142,7 @@ static bool create_softfilter_graph(rarch_softfilter_t *filt,
name[0] = '\0';
strlcpy(key, "filter", sizeof(key));
if (!config_get_array(filt->conf, key, name, sizeof(name)))
if (config_get_array(filt->conf, key, name, sizeof(name)) == 0)
{
RARCH_ERR("Could not find 'filter' array in config.\n");
return false;

142
gfx/video_shader_parse.c
View File

@ -686,7 +686,7 @@ static bool video_shader_parse_pass(config_file_t *conf,
_len = strlcpy(shader_var, "shader", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (!config_get_path(conf, shader_var, tmp_path, sizeof(tmp_path)))
if (config_get_path(conf, shader_var, tmp_path, sizeof(tmp_path)) == 0)
{
RARCH_ERR("[Shaders]: Couldn't parse shader source \"%s\".\n", shader_var);
return false;
@ -758,23 +758,28 @@ static bool video_shader_parse_pass(config_file_t *conf,
scale = &pass->fbo;
_len = strlcpy(shader_var, "scale_type", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, shader_var, scale_type, sizeof(scale_type));
_len = strlcpy(shader_var, "scale_type_x", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, shader_var, scale_type_x, sizeof(scale_type_x));
_len = strlcpy(shader_var, "scale_type_y", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, shader_var, scale_type_y, sizeof(scale_type_y));
if (*scale_type)
if (config_get_array(conf, shader_var, scale_type, sizeof(scale_type)) > 0)
{
strlcpy(scale_type_x, scale_type, sizeof(scale_type_x));
strlcpy(scale_type_y, scale_type, sizeof(scale_type_y));
}
else if (!*scale_type_x && !*scale_type_y)
return true;
else
{
size_t __len_x, __len_y;
_len = strlcpy(shader_var, "scale_type_x", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
__len_x = config_get_array(conf, shader_var, scale_type_x, sizeof(scale_type_x));
_len = strlcpy(shader_var, "scale_type_y", sizeof(shader_var));
strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
__len_y = config_get_array(conf, shader_var, scale_type_y, sizeof(scale_type_y));
if (__len_x == 0 && __len_y == 0)
return true;
}
scale->flags |= FBO_SCALE_FLAG_VALID;
scale->type_x = RARCH_SCALE_INPUT;
@ -923,13 +928,14 @@ static bool video_shader_parse_textures(config_file_t *conf,
return false;
}
config_get_path(conf, id, texture_path, sizeof(texture_path));
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(shader->lut[shader->luts].path,
PATH_MAX_LENGTH, conf->path, texture_path);
video_shader_replace_wildcards(shader->lut[shader->luts].path,
PATH_MAX_LENGTH, conf->path);
if (config_get_path(conf, id, texture_path, sizeof(texture_path)) > 0)
{
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(shader->lut[shader->luts].path,
PATH_MAX_LENGTH, conf->path, texture_path);
video_shader_replace_wildcards(shader->lut[shader->luts].path,
PATH_MAX_LENGTH, conf->path);
}
strlcpy(shader->lut[shader->luts].id, id,
sizeof(shader->lut[shader->luts].id));
@ -1328,16 +1334,18 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
/* Step through the textures in the shader */
for (i = 0; i < shader->luts; i++)
{
size_t _len;
char k[128];
fill_pathname_abbreviated_or_relative(tmp_rel,
tmp_base, shader->lut[i].path, PATH_MAX_LENGTH);
pathname_make_slashes_portable(tmp_rel);
config_set_string(conf, shader->lut[i].id, tmp_rel);
_len = strlcpy(k, shader->lut[i].id, sizeof(k));
/* Linear filter ON or OFF */
if (shader->lut[i].filter != RARCH_FILTER_UNSPEC)
{
char k[128];
size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcpy(k + _len, "_linear", sizeof(k) - _len);
config_set_string(conf, k,
(shader->lut[i].filter == RARCH_FILTER_LINEAR)
@ -1346,23 +1354,15 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
}
/* Wrap Mode */
{
char k[128];
size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcpy(k + _len, "_wrap_mode", sizeof(k) - _len);
config_set_string(conf, k,
video_shader_wrap_mode_to_str(shader->lut[i].wrap));
}
strlcpy(k + _len, "_wrap_mode", sizeof(k) - _len);
config_set_string(conf, k,
video_shader_wrap_mode_to_str(shader->lut[i].wrap));
/* Mipmap On or Off */
{
char k[128];
size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcpy(k + _len, "_mipmap", sizeof(k) - _len);
config_set_string(conf, k, shader->lut[i].mipmap
? "true"
: "false");
}
strlcpy(k + _len, "_mipmap", sizeof(k) - _len);
config_set_string(conf, k, shader->lut[i].mipmap
? "true"
: "false");
}
}
@ -2172,13 +2172,16 @@ static bool video_shader_override_values(config_file_t *override_conf,
char *tex_path = (char*)malloc(PATH_MAX_LENGTH);
/* Texture path from the config */
config_get_path(override_conf, shader->lut[i].id, tex_path, PATH_MAX_LENGTH);
if (config_get_path(override_conf, shader->lut[i].id, tex_path, PATH_MAX_LENGTH) > 0)
{
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(override_tex_path, PATH_MAX_LENGTH,
override_conf->path, tex_path);
video_shader_replace_wildcards(override_tex_path, PATH_MAX_LENGTH,
override_conf->path);
}
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(override_tex_path, PATH_MAX_LENGTH,
override_conf->path, tex_path);
video_shader_replace_wildcards(override_tex_path, PATH_MAX_LENGTH,
override_conf->path);
free(tex_path);
strlcpy(shader->lut[i].path, override_tex_path, sizeof(shader->lut[i].path));
@ -2188,7 +2191,6 @@ static bool video_shader_override_values(config_file_t *override_conf,
shader->lut[i].path);
#endif
free(tex_path);
return_val = true;
}
}
@ -2894,31 +2896,35 @@ static bool video_shader_load_shader_preset_internal(
flags.flags = 0;
video_context_driver_get_flags(&flags);
for (i = 0; i < (int)ARRAY_SIZE(types); i++)
if (!string_is_empty(core_name))
{
if (!BIT32_GET(flags.flags, video_shader_type_to_flag(types[i])))
continue;
/* Concatenate strings into full paths */
if (!string_is_empty(core_name))
for (i = 0; i < (int)ARRAY_SIZE(types); i++)
{
if (!BIT32_GET(flags.flags, video_shader_type_to_flag(types[i])))
continue;
fill_pathname_join_special_ext(s,
shader_directory, core_name,
special_name,
video_shader_get_preset_extension(types[i]),
len);
else
{
size_t _len;
if (string_is_empty(special_name))
break;
_len = fill_pathname_join(s, shader_directory, special_name, len);
strlcpy(s + _len, video_shader_get_preset_extension(types[i]), len - _len);
if (path_is_valid(s))
return true;
}
if (path_is_valid(s))
return true;
}
else if (!string_is_empty(special_name))
{
for (i = 0; i < (int)ARRAY_SIZE(types); i++)
{
if (BIT32_GET(flags.flags, video_shader_type_to_flag(types[i])))
{
size_t _len = fill_pathname_join(s, shader_directory, special_name, len);
strlcpy(s + _len, video_shader_get_preset_extension(types[i]), len - _len);
if (path_is_valid(s))
return true;
}
}
}
return false;
}
@ -3084,6 +3090,7 @@ bool video_shader_apply_shader(
const char *preset_path,
bool message)
{
size_t _len;
char msg[NAME_MAX_LENGTH];
video_driver_state_t *video_st = video_state_get_ptr();
runloop_state_t *runloop_st = runloop_state_get_ptr();
@ -3128,7 +3135,7 @@ bool video_shader_apply_shader(
{
/* Display message */
const char *msg_shader = msg_hash_to_str(MSG_SHADER);
size_t _len = strlcpy(msg, msg_shader, sizeof(msg));
_len = strlcpy(msg, msg_shader, sizeof(msg));
msg[ _len] = ':';
msg[++_len] = ' ';
if (preset_file)
@ -3143,7 +3150,7 @@ bool video_shader_apply_shader(
else
{
msg[++_len] = '\0';
strlcpy(msg + _len,
_len += strlcpy(msg + _len,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE),
sizeof(msg) - _len);
}
@ -3153,7 +3160,7 @@ bool video_shader_apply_shader(
gfx_widget_set_generic_message(msg, 2000);
else
#endif
runloop_msg_queue_push(msg, 1, 120, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -3171,14 +3178,13 @@ bool video_shader_apply_shader(
#endif
/* Display error message */
fill_pathname_join_delim(msg,
_len = fill_pathname_join_delim(msg,
msg_hash_to_str(MSG_FAILED_TO_APPLY_SHADER_PRESET),
preset_file ? preset_file : "null",
' ',
sizeof(msg));
runloop_msg_queue_push(
msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return false;
}

36
input/input_driver.c
View File

@ -6176,21 +6176,19 @@ bool replay_set_serialized_data(void* buf)
{
if (recording)
{
const char *str = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_FAILED_INCOMPAT);
runloop_msg_queue_push(str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Replay] %s.\n", str);
const char *_msg = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_FAILED_INCOMPAT);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Replay] %s.\n", _msg);
return false;
}
if (playback)
{
const char *str = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_HALT_INCOMPAT);
runloop_msg_queue_push(str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
RARCH_WARN("[Replay] %s.\n", str);
const char *_msg = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_HALT_INCOMPAT);
runloop_msg_queue_push(_msg, sizeof(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
RARCH_WARN("[Replay] %s.\n", _msg);
movie_stop(input_st);
}
}
@ -6236,21 +6234,19 @@ bool replay_set_serialized_data(void* buf)
/* otherwise, if recording do not allow the load */
if (recording)
{
const char *str = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_FAILED_INCOMPAT);
runloop_msg_queue_push(str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Replay] %s.\n", str);
const char *_msg = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_FAILED_INCOMPAT);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Replay] %s.\n", _msg);
return false;
}
/* if in playback, halt playback and go to that state normally */
if (playback)
{
const char *str = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_HALT_INCOMPAT);
runloop_msg_queue_push(str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
RARCH_WARN("[Replay] %s.\n", str);
const char *_msg = msg_hash_to_str(MSG_REPLAY_LOAD_STATE_HALT_INCOMPAT);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
RARCH_WARN("[Replay] %s.\n", _msg);
movie_stop(input_st);
}
}

2
libretro-common/audio/dsp_filter.c
View File

@ -112,7 +112,7 @@ static bool create_filter_graph(retro_dsp_filter_t *dsp, float sample_rate)
snprintf(key, sizeof(key), "filter%u", i);
if (!config_get_array(dsp->conf, key, name, sizeof(name)))
if (config_get_array(dsp->conf, key, name, sizeof(name)) == 0)
return false;
dsp->instances[i].impl = find_implementation(dsp, name);

33
libretro-common/file/config_file.c
View File

@ -355,12 +355,7 @@ static void config_file_add_child_list(config_file_t *parent,
static void config_file_get_realpath(char *s, size_t len,
char *path, const char *config_path)
{
#ifdef _WIN32
if (!string_is_empty(config_path))
fill_pathname_resolve_relative(s, config_path,
path, len);
#else
#if !defined(__PSL1GHT__) && !defined(__PS3__)
#if !defined(_WIN32) && !defined(__PSL1GHT__) && !defined(__PS3__)
if (*path == '~')
{
const char *home = getenv("HOME");
@ -374,9 +369,11 @@ static void config_file_get_realpath(char *s, size_t len,
}
else
#endif
{
if (!string_is_empty(config_path))
fill_pathname_resolve_relative(s, config_path, path, len);
#endif
fill_pathname_resolve_relative(s, config_path,
path, len);
}
}
static void config_file_add_sub_conf(config_file_t *conf, char *path,
@ -1163,37 +1160,33 @@ bool config_get_string(config_file_t *conf, const char *key, char **str)
* Extracts a string to a preallocated buffer.
* Avoid memory allocation.
**/
bool config_get_config_path(config_file_t *conf, char *s, size_t len)
size_t config_get_config_path(config_file_t *conf, char *s, size_t len)
{
if (conf)
return strlcpy(s, conf->path, len);
return false;
return 0;
}
bool config_get_array(config_file_t *conf, const char *key,
size_t config_get_array(config_file_t *conf, const char *key,
char *buf, size_t size)
{
const struct config_entry_list *entry = config_get_entry(conf, key);
if (entry)
return strlcpy(buf, entry->value, size) < size;
return false;
return 0;
}
bool config_get_path(config_file_t *conf, const char *key,
size_t config_get_path(config_file_t *conf, const char *key,
char *buf, size_t size)
{
#if defined(RARCH_CONSOLE) || !defined(RARCH_INTERNAL)
if (config_get_array(conf, key, buf, size))
return true;
return config_get_array(conf, key, buf, size);
#else
const struct config_entry_list *entry = config_get_entry(conf, key);
if (entry)
{
fill_pathname_expand_special(buf, entry->value, size);
return true;
}
return fill_pathname_expand_special(buf, entry->value, size);
#endif
return false;
return 0;
}
/**

6
libretro-common/include/file/config_file.h
View File

@ -263,7 +263,7 @@ bool config_get_char(config_file_t *conf, const char *entry, char *in);
bool config_get_string(config_file_t *conf, const char *entry, char **in);
/* Extracts a string to a preallocated buffer. Avoid memory allocation. */
bool config_get_array(config_file_t *conf, const char *entry, char *s, size_t len);
size_t config_get_array(config_file_t *conf, const char *entry, char *s, size_t len);
/**
* config_get_config_path:
@ -274,11 +274,11 @@ bool config_get_array(config_file_t *conf, const char *entry, char *s, size_t le
* Hidden non-leaf function cost:
* - Calls strlcpy
**/
bool config_get_config_path(config_file_t *conf, char *s, size_t len);
size_t config_get_config_path(config_file_t *conf, char *s, size_t len);
/* Extracts a string to a preallocated buffer. Avoid memory allocation.
* Recognized magic like ~/. Similar to config_get_array() otherwise. */
bool config_get_path(config_file_t *conf, const char *entry, char *s, size_t len);
size_t config_get_path(config_file_t *conf, const char *entry, char *s, size_t len);
/**
* config_get_bool:

304
menu/cbs/menu_cbs_ok.c
View File

@ -2881,6 +2881,7 @@ static int action_ok_playlist_entry_collection(const char *path,
error:
runloop_msg_queue_push(
"File could not be loaded from playlist.\n",
STRLEN_CONST("File could not be loaded from playlist.\n"),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
@ -2973,12 +2974,11 @@ static int action_ok_load_cdrom(const char *path,
if (!cdrom_drive_has_media(label[0]))
{
const char *_msg = msg_hash_to_str(MSG_NO_DISC_INSERTED);
RARCH_LOG("[CDROM]: No media is inserted or drive is not ready.\n");
runloop_msg_queue_push(
msg_hash_to_str(MSG_NO_DISC_INSERTED),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
}
@ -3013,12 +3013,11 @@ static int action_ok_load_cdrom(const char *path,
}
else
{
const char *_msg = msg_hash_to_str(MSG_LOAD_CORE_FIRST);
RARCH_LOG("[CDROM]: Cannot load disc without a core.\n");
runloop_msg_queue_push(
msg_hash_to_str(MSG_LOAD_CORE_FIRST),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
}
@ -3034,11 +3033,10 @@ static int action_ok_dump_cdrom(const char *path,
#ifdef HAVE_CDROM
if (!cdrom_drive_has_media(label[0]))
{
const char *_msg = msg_hash_to_str(MSG_NO_DISC_INSERTED);
RARCH_LOG("[CDROM]: No media is inserted or drive is not ready.\n");
runloop_msg_queue_push(
msg_hash_to_str(MSG_NO_DISC_INSERTED),
1, 100, true,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
@ -3296,18 +3294,18 @@ static void menu_input_st_string_cb_disable_kiosk_mode(void *userdata,
if (string_is_equal(label, path_kiosk_mode_password))
{
const char *_msg = msg_hash_to_str(MSG_INPUT_KIOSK_MODE_PASSWORD_OK);
settings->bools.kiosk_mode_enable = false;
runloop_msg_queue_push(
msg_hash_to_str(MSG_INPUT_KIOSK_MODE_PASSWORD_OK),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_INPUT_KIOSK_MODE_PASSWORD_NOK),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_INPUT_KIOSK_MODE_PASSWORD_NOK);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
menu_input_dialog_end();
@ -3325,18 +3323,18 @@ static void menu_input_st_string_cb_enable_settings(void *userdata,
if (string_is_equal(label, menu_content_show_settings_password))
{
const char *_msg = msg_hash_to_str(MSG_INPUT_ENABLE_SETTINGS_PASSWORD_OK);
settings->bools.menu_content_show_settings = true;
runloop_msg_queue_push(
msg_hash_to_str(MSG_INPUT_ENABLE_SETTINGS_PASSWORD_OK),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_INPUT_ENABLE_SETTINGS_PASSWORD_NOK),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_INPUT_ENABLE_SETTINGS_PASSWORD_NOK);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
menu_input_dialog_end();
@ -3392,15 +3390,17 @@ static void menu_input_st_string_cb_save_preset(void *userdata,
true);
if (ret)
runloop_msg_queue_push(
msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
menu_input_dialog_end();
@ -3458,17 +3458,17 @@ static int generic_action_ok_shader_preset_remove(const char *path,
dir_video_shader, dir_menu_config))
{
struct menu_state *menu_st = menu_state_get_ptr();
runloop_msg_queue_push(
msg_hash_to_str(MSG_SHADER_PRESET_REMOVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_REMOVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_REMOVING_SHADER_PRESET),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_REMOVING_SHADER_PRESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return 0;
}
@ -3508,15 +3508,17 @@ static int generic_action_ok_shader_preset_save(const char *path,
if (menu_shader_manager_save_auto_preset(menu_shader_get(), preset_type,
dir_video_shader, dir_menu_config,
true))
runloop_msg_queue_push(
msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return 0;
}
@ -3763,6 +3765,7 @@ static int generic_action_ok_remap_file_operation(const char *path,
if (action_type < ACTION_OK_REMAP_FILE_REMOVE_CORE)
{
const char *_msg;
if ( !string_is_empty(remap_file_path)
&& input_remapping_save_file(remap_file_path))
{
@ -3779,18 +3782,18 @@ static int generic_action_ok_remap_file_operation(const char *path,
break;
}
runloop_msg_queue_push(
msg_hash_to_str(MSG_REMAP_FILE_SAVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_REMAP_FILE_SAVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* TODO/FIXME - localize */
RARCH_LOG("[Remap]: File saved successfully: \"%s\".\n",remap_file_path);
}
else
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_SAVING_REMAP_FILE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_ERROR_SAVING_REMAP_FILE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* TODO/FIXME - localize */
RARCH_ERR("[Remap]: File save unsuccessful: \"%s\".\n",remap_file_path);
}
}
@ -3799,6 +3802,7 @@ static int generic_action_ok_remap_file_operation(const char *path,
if ( !string_is_empty(remap_file_path)
&& (filestream_delete(remap_file_path) == 0))
{
const char *_msg;
uint32_t flags = runloop_get_flags();
switch (action_type)
{
@ -3816,10 +3820,9 @@ static int generic_action_ok_remap_file_operation(const char *path,
break;
}
runloop_msg_queue_push(
msg_hash_to_str(MSG_REMAP_FILE_REMOVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_REMAP_FILE_REMOVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* After removing a remap file, attempt to
* load any remaining remap file with the
@ -3827,10 +3830,11 @@ static int generic_action_ok_remap_file_operation(const char *path,
config_load_remap(directory_input_remapping, sys_info);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_REMOVING_REMAP_FILE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_REMOVING_REMAP_FILE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
/* Refresh menu */
@ -3920,17 +3924,17 @@ static int action_ok_remap_file_remove_game(const char *path,
static int action_ok_remap_file_reset(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
const char *_msg = msg_hash_to_str(MSG_REMAP_FILE_RESET);
input_remapping_set_defaults(false);
runloop_msg_queue_push(
msg_hash_to_str(MSG_REMAP_FILE_RESET),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
static int action_ok_remap_file_flush(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
runloop_state_t *runloop_st = runloop_state_get_ptr();
const char *path_remapfile = runloop_st->name.remapfile;
@ -3958,7 +3962,7 @@ static int action_ok_remap_file_flush(const char *path,
RARCH_LOG(
"[Remaps]: Saved input remapping options to \"%s\".\n",
path_remapfile ? path_remapfile : "UNKNOWN");
snprintf(msg, sizeof(msg), "%s \"%s\"",
_len = snprintf(msg, sizeof(msg), "%s \"%s\"",
msg_hash_to_str(MSG_REMAP_FILE_FLUSHED),
remapfile);
}
@ -3968,14 +3972,13 @@ static int action_ok_remap_file_flush(const char *path,
RARCH_LOG(
"[Remaps]: Failed to save input remapping options to \"%s\".\n",
path_remapfile ? path_remapfile : "UNKNOWN");
snprintf(msg, sizeof(msg), "%s \"%s\"",
_len = snprintf(msg, sizeof(msg), "%s \"%s\"",
msg_hash_to_str(MSG_REMAP_FILE_FLUSH_FAILED),
remapfile);
}
runloop_msg_queue_push(
msg, 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -4023,10 +4026,8 @@ static void menu_input_st_string_cb_override_file_save_as(
break;
}
runloop_msg_queue_push(
msg_str,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg_str, strlen(msg_str), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
menu_input_dialog_end();
@ -4043,10 +4044,11 @@ static int action_ok_override_unload(const char *path,
{
#ifdef HAVE_CONFIGFILE
if (config_unload_override())
runloop_msg_queue_push(
msg_hash_to_str(MSG_OVERRIDES_UNLOADED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_OVERRIDES_UNLOADED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#endif
return 0;
}
@ -4154,9 +4156,10 @@ static int action_ok_core_deferred_set(const char *new_core_path,
&entry);
/* Provide visual feedback */
_len = strlcpy(msg, msg_hash_to_str(MSG_SET_CORE_ASSOCIATION), sizeof(msg));
strlcpy(msg + _len, core_display_name, sizeof(msg) - _len);
runloop_msg_queue_push(msg, 1, 100, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_len = strlcpy(msg, msg_hash_to_str(MSG_SET_CORE_ASSOCIATION), sizeof(msg));
_len += strlcpy(msg + _len, core_display_name, sizeof(msg) - _len);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
menu_entries_pop_stack(&selection, 0, 1);
menu_st->selection_ptr = selection;
@ -4191,10 +4194,10 @@ static int action_ok_set_switch_cpu_profile(const char *path,
clkrstCloseSession(&session);
}
/* TODO/FIXME - localize */
_len = strlcpy(command, "Current clock set to", sizeof(command));
snprintf(command + _len, sizeof(command) - _len, "%i", profile_clock);
_len = strlcpy(command, "Current clock set to", sizeof(command));
_len += snprintf(command + _len, sizeof(command) - _len, "%i", profile_clock);
runloop_msg_queue_push(command, 1, 90, true, NULL,
runloop_msg_queue_push(command, _len, 1, 90, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
@ -4413,6 +4416,7 @@ static int action_ok_cheat_add_top(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
int i;
size_t _len;
char msg[128];
struct item_cheat tmp;
struct menu_state *menu_st = menu_state_get_ptr();
@ -4435,10 +4439,9 @@ static int action_ok_cheat_add_top(const char *path,
memcpy(&cheat_manager_state.cheats[0], &tmp, sizeof(struct item_cheat));
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_TOP_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_TOP_SUCCESS), sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
@ -4447,6 +4450,7 @@ static int action_ok_cheat_add_top(const char *path,
static int action_ok_cheat_add_bottom(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
struct menu_state *menu_st = menu_state_get_ptr();
unsigned int new_size = cheat_manager_get_size() + 1;
@ -4455,11 +4459,10 @@ static int action_ok_cheat_add_bottom(const char *path,
| MENU_ST_FLAG_PREVENT_POPULATE;
cheat_manager_realloc(new_size, CHEAT_HANDLER_TYPE_EMU);
strlcpy(msg,
_len = strlcpy(msg,
msg_hash_to_str(MSG_CHEAT_ADD_BOTTOM_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
@ -4468,6 +4471,7 @@ static int action_ok_cheat_add_bottom(const char *path,
static int action_ok_cheat_delete_all(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
struct menu_state *menu_st = menu_state_get_ptr();
@ -4476,11 +4480,10 @@ static int action_ok_cheat_delete_all(const char *path,
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
| MENU_ST_FLAG_PREVENT_POPULATE;
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_DELETE_ALL_SUCCESS),
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_DELETE_ALL_SUCCESS),
sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
@ -4490,6 +4493,7 @@ static int action_ok_cheat_add_new_after(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
int i;
size_t _len;
char msg[128];
struct item_cheat tmp;
struct menu_state *menu_st = menu_state_get_ptr();
@ -4512,10 +4516,11 @@ static int action_ok_cheat_add_new_after(const char *path,
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
| MENU_ST_FLAG_PREVENT_POPULATE;
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_AFTER_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_AFTER_SUCCESS),
sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -4524,6 +4529,7 @@ static int action_ok_cheat_add_new_before(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
int i;
size_t _len;
char msg[128];
struct item_cheat tmp;
struct menu_state *menu_st = menu_state_get_ptr();
@ -4548,10 +4554,10 @@ static int action_ok_cheat_add_new_before(const char *path,
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
| MENU_ST_FLAG_PREVENT_POPULATE;
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_BEFORE_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_ADD_BEFORE_SUCCESS), sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -4560,8 +4566,9 @@ static int action_ok_cheat_copy_before(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
int i;
struct item_cheat tmp;
size_t _len;
char msg[128];
struct item_cheat tmp;
struct menu_state *menu_st = menu_state_get_ptr();
unsigned int new_size = cheat_manager_get_size() + 1;
cheat_manager_realloc(new_size, CHEAT_HANDLER_TYPE_RETRO);
@ -4585,10 +4592,10 @@ static int action_ok_cheat_copy_before(const char *path,
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
| MENU_ST_FLAG_PREVENT_POPULATE;
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_COPY_BEFORE_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_COPY_BEFORE_SUCCESS), sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -4597,6 +4604,7 @@ static int action_ok_cheat_copy_after(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
int i;
size_t _len;
char msg[128];
struct item_cheat tmp;
struct menu_state *menu_st = menu_state_get_ptr();
@ -4622,10 +4630,11 @@ static int action_ok_cheat_copy_after(const char *path,
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
| MENU_ST_FLAG_PREVENT_POPULATE;
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_COPY_AFTER_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_COPY_AFTER_SUCCESS),
sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
@ -4633,6 +4642,7 @@ static int action_ok_cheat_copy_after(const char *path,
static int action_ok_cheat_delete(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
size_t new_selection_ptr = 0;
struct menu_state *menu_st = menu_state_get_ptr();
@ -4663,10 +4673,10 @@ static int action_ok_cheat_delete(const char *path,
cheat_manager_realloc(new_size, CHEAT_HANDLER_TYPE_RETRO);
strlcpy(msg, msg_hash_to_str(MSG_CHEAT_DELETE_SUCCESS), sizeof(msg));
msg[sizeof(msg) - 1] = 0; /* TODO/FIXME - is this necessary? */
_len = strlcpy(msg, msg_hash_to_str(MSG_CHEAT_DELETE_SUCCESS), sizeof(msg));
runloop_msg_queue_push(msg, 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
new_selection_ptr = menu_st->selection_ptr;
menu_entries_pop_stack(&new_selection_ptr, 0, 1);
@ -6682,6 +6692,7 @@ static int action_ok_push_netplay_refresh_lan(const char *path,
static int action_ok_push_netplay_kick(const char *path, const char *label,
unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
netplay_client_info_t client;
@ -6689,13 +6700,13 @@ static int action_ok_push_netplay_kick(const char *path, const char *label,
strlcpy(client.name, path, sizeof(client.name));
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_KICK_CLIENT, &client))
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_KICKED_CLIENT_S), client.name);
else
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_FAILED_TO_KICK_CLIENT_S), client.name);
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return action_cancel_pop_default(NULL, NULL, 0, 0);
@ -6704,6 +6715,7 @@ static int action_ok_push_netplay_kick(const char *path, const char *label,
static int action_ok_push_netplay_ban(const char *path, const char *label,
unsigned type, size_t idx, size_t entry_idx)
{
size_t _len;
char msg[128];
netplay_client_info_t client;
@ -6711,13 +6723,13 @@ static int action_ok_push_netplay_ban(const char *path, const char *label,
strlcpy(client.name, path, sizeof(client.name));
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_BAN_CLIENT, &client))
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_BANNED_CLIENT_S), client.name);
else
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_FAILED_TO_BAN_CLIENT_S), client.name);
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return action_cancel_pop_default(NULL, NULL, 0, 0);
@ -7769,6 +7781,7 @@ static int action_ok_video_resolution(const char *path,
if (video_driver_get_video_output_size(&width, &height, desc, sizeof(desc)))
{
size_t _len;
char msg[128];
msg[0] = '\0';
@ -7778,21 +7791,21 @@ static int action_ok_video_resolution(const char *path,
video_driver_set_video_mode(width, height, true);
#ifdef GEKKO
if (width == 0 || height == 0)
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_SCREEN_RESOLUTION_APPLYING_DEFAULT));
else
#endif
{
if (!string_is_empty(desc))
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_SCREEN_RESOLUTION_APPLYING_DESC),
width, height, desc);
else
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_SCREEN_RESOLUTION_APPLYING_NO_DESC),
width, height);
}
runloop_msg_queue_push(msg, 1, 100, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -8078,18 +8091,15 @@ static void action_ok_netplay_enable_client_hostname_cb(void *userdata,
else if (!task_push_netplay_content_reload(line))
{
#ifdef HAVE_DYNAMIC
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED);
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
command_event(CMD_EVENT_NETPLAY_INIT_DIRECT_DEFERRED, (void*)line);
runloop_msg_queue_push(
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED),
1, 480, true, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#else
runloop_msg_queue_push(
msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED),
1, 480, true, NULL,
const char *_msg = msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#endif
menu_input_dialog_end();
@ -8239,14 +8249,13 @@ int action_ok_core_lock(const char *path,
sizeof(msg));
if (!string_is_empty(core_name))
strlcpy(msg + _len, core_name, sizeof(msg) - _len);
_len += strlcpy(msg + _len, core_name, sizeof(msg) - _len);
/* Generate log + notification */
RARCH_ERR("%s\n", msg);
runloop_msg_queue_push(msg,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
ret = -1;
}
@ -8301,15 +8310,13 @@ int action_ok_core_set_standalone_exempt(const char *path,
sizeof(msg));
if (!string_is_empty(core_name))
strlcpy(msg + _len, core_name, sizeof(msg) - _len);
_len += strlcpy(msg + _len, core_name, sizeof(msg) - _len);
/* Generate log + notification */
RARCH_ERR("%s\n", msg);
runloop_msg_queue_push(
msg,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
}
@ -8348,12 +8355,10 @@ static int action_ok_core_delete(const char *path,
_len = strlcpy(msg, msg_hash_to_str(MSG_CORE_DELETE_DISABLED), sizeof(msg));
if (!string_is_empty(core_name))
strlcpy(msg + _len, core_name, sizeof(msg) - _len);
_len += strlcpy(msg + _len, core_name, sizeof(msg) - _len);
runloop_msg_queue_push(
msg,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* We do not consider this an 'error' - we are
* merely telling the user that this operation
@ -8547,6 +8552,7 @@ static int action_ok_playlist_refresh(const char *path,
if (stat != MANUAL_CONTENT_SCAN_PLAYLIST_REFRESH_OK)
{
size_t _len;
char msg[128];
char system_name[256];
const char *msg_prefix = NULL;
@ -8601,10 +8607,10 @@ static int action_ok_playlist_refresh(const char *path,
* scan record */
if (string_is_empty(msg_subject))
msg_subject = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE);
fill_pathname_join_special(msg, msg_prefix, msg_subject, sizeof(msg));
_len = fill_pathname_join_special(msg, msg_prefix, msg_subject, sizeof(msg));
RARCH_ERR(log_text, msg_subject);
runloop_msg_queue_push(msg, 1, 150, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 150, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* Even though this is a failure condition, we
* let it fall-through to 0 here to suppress
* any refreshing of the menu (this can appear

26
menu/cbs/menu_cbs_start.c
View File

@ -602,6 +602,7 @@ static int action_start_video_resolution(
if (video_driver_get_video_output_size(&width, &height, desc, sizeof(desc)))
{
size_t _len;
char msg[128];
msg[0] = '\0';
@ -611,19 +612,20 @@ static int action_start_video_resolution(
video_driver_set_video_mode(width, height, true);
#ifdef GEKKO
if (width == 0 || height == 0)
strlcpy(msg, "Resetting to: DEFAULT", sizeof(msg));
_len = strlcpy(msg, "Resetting to: DEFAULT", sizeof(msg));
else
#endif
{
if (!string_is_empty(desc))
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_RESETTING_DESC),
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_RESETTING_DESC),
width, height, desc);
else
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_RESETTING_NO_DESC),
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_RESETTING_NO_DESC),
width, height);
}
runloop_msg_queue_push(msg, 1, 100, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#endif
@ -712,15 +714,13 @@ static int action_start_core_lock(
_len = strlcpy(msg, msg_hash_to_str(MSG_CORE_UNLOCK_FAILED), sizeof(msg));
if (!string_is_empty(core_name))
strlcpy(msg + _len, core_name, sizeof(msg) - _len);
_len += strlcpy(msg + _len, core_name, sizeof(msg) - _len);
/* Generate log + notification */
RARCH_ERR("%s\n", msg);
runloop_msg_queue_push(
msg,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
ret = -1;
}
@ -772,15 +772,13 @@ static int action_start_core_set_standalone_exempt(
sizeof(msg));
if (!string_is_empty(core_name))
strlcpy(msg + _len, core_name, sizeof(msg) - _len);
_len += strlcpy(msg + _len, core_name, sizeof(msg) - _len);
/* Generate log + notification */
RARCH_ERR("%s\n", msg);
runloop_msg_queue_push(
msg,
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return -1;
}

41
menu/drivers/rgui.c
View File

@ -1499,15 +1499,15 @@ static bool rgui_fonts_init(rgui_t *rgui)
rgui->fonts.jpn_10x10 = bitmapfont_10x10_load(RETRO_LANGUAGE_JAPANESE);
rgui->fonts.kor_10x10 = bitmapfont_10x10_load(RETRO_LANGUAGE_KOREAN);
if (!rgui->fonts.eng_10x10 ||
!rgui->fonts.chn_10x10 ||
!rgui->fonts.jpn_10x10 ||
!rgui->fonts.kor_10x10)
if ( !rgui->fonts.eng_10x10
|| !rgui->fonts.chn_10x10
|| !rgui->fonts.jpn_10x10
|| !rgui->fonts.kor_10x10)
{
const char *_msg = msg_hash_to_str(MSG_RGUI_MISSING_FONTS);
rgui_fonts_free(rgui);
*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE) = RETRO_LANGUAGE_ENGLISH;
runloop_msg_queue_push(
msg_hash_to_str(MSG_RGUI_MISSING_FONTS), 1, 256, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 256, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto english;
}
@ -1526,13 +1526,13 @@ static bool rgui_fonts_init(rgui_t *rgui)
rgui->fonts.eng_10x10 = bitmapfont_10x10_load(RETRO_LANGUAGE_ENGLISH);
rgui->fonts.rus_10x10 = bitmapfont_10x10_load(RETRO_LANGUAGE_RUSSIAN);
if (!rgui->fonts.eng_10x10 ||
!rgui->fonts.rus_10x10)
if ( !rgui->fonts.eng_10x10
|| !rgui->fonts.rus_10x10)
{
const char *_msg = msg_hash_to_str(MSG_RGUI_MISSING_FONTS);
rgui_fonts_free(rgui);
*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE) = RETRO_LANGUAGE_ENGLISH;
runloop_msg_queue_push(
msg_hash_to_str(MSG_RGUI_MISSING_FONTS), 1, 256, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 256, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto english;
}
@ -1565,13 +1565,13 @@ static bool rgui_fonts_init(rgui_t *rgui)
rgui->fonts.eng_6x10 = bitmapfont_6x10_load(RETRO_LANGUAGE_ENGLISH);
rgui->fonts.lse_6x10 = bitmapfont_6x10_load(language);
if (!rgui->fonts.eng_6x10 ||
!rgui->fonts.lse_6x10)
if ( !rgui->fonts.eng_6x10
|| !rgui->fonts.lse_6x10)
{
const char *_msg = msg_hash_to_str(MSG_RGUI_MISSING_FONTS);
rgui_fonts_free(rgui);
*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE) = RETRO_LANGUAGE_ENGLISH;
runloop_msg_queue_push(
msg_hash_to_str(MSG_RGUI_MISSING_FONTS), 1, 256, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 256, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto english;
}
@ -1589,13 +1589,15 @@ static bool rgui_fonts_init(rgui_t *rgui)
case RETRO_LANGUAGE_PERSIAN:
case RETRO_LANGUAGE_HEBREW:
default:
{
const char *_msg = msg_hash_to_str(MSG_RGUI_INVALID_LANGUAGE);
/* We do not have fonts for these
* languages - fallback to English */
*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE) = RETRO_LANGUAGE_ENGLISH;
runloop_msg_queue_push(
msg_hash_to_str(MSG_RGUI_INVALID_LANGUAGE), 1, 256, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 256, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto english;
}
}
return true;
@ -3147,9 +3149,6 @@ static void rgui_load_custom_theme(
particle_color = (normal_color & 0x00FFFFFF) |
(bg_light_color & 0xFF000000);
config_get_array(conf, wallpaper_key,
wallpaper_file, sizeof(wallpaper_file));
success = true;
end:
@ -3166,8 +3165,10 @@ end:
theme_colors->shadow_color = (uint32_t)shadow_color;
theme_colors->particle_color = (uint32_t)particle_color;
/* Load wallpaper, if required */
if (!string_is_empty(wallpaper_file))
if (config_get_array(conf, wallpaper_key,
wallpaper_file, sizeof(wallpaper_file)) > 0)
{
char wallpaper_path[PATH_MAX_LENGTH];
wallpaper_path[0] = '\0';

12
menu/menu_displaylist.c
View File

@ -12674,13 +12674,11 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
}
else
{
const char *_msg = msg_hash_to_str(MSG_NO_DISC_INSERTED);
/* TODO/FIXME - localize */
RARCH_LOG("[CDROM]: No media is inserted or drive is not ready.\n");
runloop_msg_queue_push(
msg_hash_to_str(MSG_NO_DISC_INSERTED),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (count == 0)
@ -12825,7 +12823,9 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
char text[128];
const size_t profiles_count = sizeof(SWITCH_CPU_PROFILES)/sizeof(SWITCH_CPU_PROFILES[1]);
/* TODO/FIXME - localize */
runloop_msg_queue_push("Warning : extended overclocking can damage the Switch",
runloop_msg_queue_push(
"Warning : extended overclocking can damage the Switch",
STRLEN_CONST("Warning : extended overclocking can damage the Switch"),
1, 90, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
menu_entries_clear(info->list);
{

14
menu/menu_explore.c
View File

@ -1022,13 +1022,12 @@ static const char* explore_get_view_path(struct menu_state *menu_st, menu_list_t
static void explore_on_edit_views(enum msg_hash_enums msg)
{
const char *_msg = msg_hash_to_str(msg);
struct menu_state *menu_st = menu_state_get_ptr();
if (menu_st->driver_ctx->environ_cb)
menu_st->driver_ctx->environ_cb(MENU_ENVIRON_RESET_HORIZONTAL_LIST,
NULL, menu_st->userdata);
runloop_msg_queue_push(msg_hash_to_str(msg),
1, 180, true, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -1070,15 +1069,14 @@ static void explore_action_saveview_complete(void *userdata, const char *name)
if (filestream_exists(lvwpath))
{
runloop_msg_queue_push(msg_hash_to_str(MENU_ENUM_LABEL_EXPLORE_VIEW_EXISTS),
1, 360, true, NULL,
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_EXPLORE_VIEW_EXISTS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 360, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return;
}
file = intfstream_open_file(lvwpath,
RETRO_VFS_FILE_ACCESS_WRITE, RETRO_VFS_FILE_ACCESS_HINT_NONE);
if (!file)
if (!(file = intfstream_open_file(lvwpath,
RETRO_VFS_FILE_ACCESS_WRITE, RETRO_VFS_FILE_ACCESS_HINT_NONE)))
{
RARCH_ERR("[explore view] Failed to write json file %s.\n", lvwpath);
return;

59
menu/menu_setting.c
View File

@ -2566,21 +2566,23 @@ static int setting_action_ok_bind_all_save_autoconfig(
map = settings->uints.input_joypad_index[index_offset];
name = input_config_get_device_name(map);
if (!string_is_empty(name) &&
config_save_autoconf_profile(name, index_offset))
if ( !string_is_empty(name)
&& config_save_autoconf_profile(name, index_offset))
{
size_t _len;
char buf[128];
char msg[NAME_MAX_LENGTH];
config_get_autoconf_profile_filename(name, index_offset, buf, sizeof(buf));
snprintf(msg, sizeof(msg),msg_hash_to_str(MSG_AUTOCONFIG_FILE_SAVED_SUCCESSFULLY_NAMED), buf);
runloop_msg_queue_push(
msg, 1, 180, true,
_len = snprintf(msg, sizeof(msg),msg_hash_to_str(MSG_AUTOCONFIG_FILE_SAVED_SUCCESSFULLY_NAMED), buf);
runloop_msg_queue_push(msg, _len, 1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_AUTOCONFIG_FILE_ERROR_SAVING), 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_AUTOCONFIG_FILE_ERROR_SAVING);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return 0;
}
@ -8509,17 +8511,15 @@ static void general_write_handler(rarch_setting_t *setting)
if (!frontend_driver_set_gamemode(on) && on)
{
#ifdef __linux__
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE_LINUX);
#else
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE);
#endif
/* If we failed to enable game mode, display
* a notification and force disable the feature */
runloop_msg_queue_push(
#ifdef __linux__
msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE_LINUX),
#else
msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE),
#endif
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
configuration_set_bool(settings,
settings->bools.gamemode_enable, false);
}
@ -9120,16 +9120,18 @@ static void general_write_handler(rarch_setting_t *setting)
switch (manual_content_scan_validate_dat_file_path())
{
case MANUAL_CONTENT_SCAN_DAT_FILE_INVALID:
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_INVALID),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_INVALID);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
break;
case MANUAL_CONTENT_SCAN_DAT_FILE_TOO_LARGE:
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_TOO_LARGE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_TOO_LARGE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
break;
default:
/* No action required */
@ -9205,6 +9207,7 @@ static void general_write_handler(rarch_setting_t *setting)
if (!core_info_cache_force_refresh(!string_is_empty(path_libretro_info) ?
path_libretro_info : dir_libretro))
{
const char *_msg = msg_hash_to_str(MSG_CORE_INFO_CACHE_UNSUPPORTED);
/* core_info_cache_force_refresh() will fail
* if we cannot write to the the core_info
* directory. This will typically only happen
@ -9215,10 +9218,8 @@ static void general_write_handler(rarch_setting_t *setting)
* so we simply force-disable the feature */
configuration_set_bool(settings,
settings->bools.core_info_cache_enable, false);
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_INFO_CACHE_UNSUPPORTED),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;

170
network/drivers_wifi/connmanctl.c
View File

@ -142,7 +142,7 @@ static bool connmanctl_tether_status(connman_t *connman)
/* Returns true if the tethering is active
* false when tethering is not active
*/
size_t ln_size;
size_t ln_len;
FILE *command_file = NULL;
char ln[3] = {0};
@ -163,18 +163,16 @@ static bool connmanctl_tether_status(connman_t *connman)
fgets(ln, sizeof(ln), command_file);
ln_size = strlen(ln) - 1;
if (ln[ln_size] == '\n')
ln[ln_size] = '\0';
ln_len = strlen(ln) - 1;
if (ln[ln_len] == '\n')
ln[ln_len] = '\0';
RARCH_LOG("[CONNMANCTL] Tether Status: command: \"%s\", output: \"%s\"\n",
connman->command, ln);
pclose(command_file);
if (!ln)
return false;
if (ln[0] == '0')
if (!ln || ln[0] == '0')
return false;
if (ln[0] == '1')
return true;
@ -203,9 +201,9 @@ static void connmanctl_tether_toggle(
while (fgets(output, sizeof(output), command_file))
{
size_t output_size = strlen(output) - 1;
if (output[output_size] == '\n')
output[output_size] = '\0';
size_t output_len = strlen(output) - 1;
if (output[output_len] == '\n')
output[output_len] = '\0';
RARCH_LOG("[CONNMANCTL] Tether toggle: output: \"%s\"\n",
output);
@ -213,7 +211,7 @@ static void connmanctl_tether_toggle(
#ifdef HAVE_GFX_WIDGETS
if (!widgets_active)
#endif
runloop_msg_queue_push(output, 1, 180, true,
runloop_msg_queue_push(output, output_len, 1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -243,9 +241,9 @@ static void connmanctl_scan(void *data)
if (connmanctl_tether_status(connman))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
configuration_set_bool(settings,
settings->bools.localap_enable, false);
connmanctl_tether_toggle(connman, false, "", "");
@ -253,9 +251,11 @@ static void connmanctl_scan(void *data)
pclose(popen("connmanctl scan wifi", "r"));
runloop_msg_queue_push(msg_hash_to_str(MSG_WIFI_SCAN_COMPLETE),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_WIFI_SCAN_COMPLETE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
/* Refresh now the services, to read the discovered networks */
connman->scan.scan_time = time(NULL);
@ -379,9 +379,9 @@ static bool connmanctl_connect_ssid(
if (connmanctl_tether_status(connman))
{
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
configuration_set_bool(settings,
settings->bools.localap_enable, false);
connmanctl_tether_toggle(connman, false, "", "");
@ -416,13 +416,25 @@ static bool connmanctl_connect_ssid(
#endif
{
if (success)
runloop_msg_queue_push("Connected", 1, 180, true,
{
/* TODO/FIXME - localize */
runloop_msg_queue_push(
"Connected",
STRLEN_CONST("Connected"),
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push("Connection failed!", 1, 180, true,
{
/* TODO/FIXME - localize */
runloop_msg_queue_push(
"Connection failed!",
STRLEN_CONST("Connection failed!"),
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
}
}
return success;
@ -466,21 +478,21 @@ static void connmanctl_get_connected_ssid(
connman->command, (ssid_size + 1) ? ssid : "<nothing_found>");
}
static void connmanctl_get_connected_servicename(
connman_t *connman, char* servicename, size_t buffersize)
static size_t connmanctl_get_connected_servicename(
connman_t *connman, char *s, size_t len)
{
/* Stores the service name of currently connected Wi-Fi
* network in servicename
* network in @s
*/
FILE *command_file = NULL;
FILE *service_file = NULL;
char ln[3] = {0};
char *temp;
char *tmp;
if (buffersize < 1)
return;
if (len < 1)
return 0;
temp = (char*)malloc(sizeof(char) * buffersize);
tmp = (char*)malloc(sizeof(char) * len);
/* Following command lists all stored services in
* connman settings folder, which are then used in
@ -500,16 +512,16 @@ static void connmanctl_get_connected_servicename(
RARCH_LOG("[CONNMANCTL] Testing configured services for activity: command: \"%s\"\n",
connman->command);
while (fgets(temp, buffersize, command_file))
while (fgets(tmp, len, command_file))
{
size_t ln_size;
size_t temp_size = strlen(temp) - 1;
size_t ln_len;
size_t tmp_len = strlen(tmp) - 1;
if ((temp_size + 1) > 0)
if (temp[temp_size] == '\n')
temp[temp_size] = '\0';
if ((tmp_len + 1) > 0)
if (tmp[tmp_len] == '\n')
tmp[tmp_len] = '\0';
if ((temp_size + 1) == 0)
if ((tmp_len + 1) == 0)
{
RARCH_WARN("[CONNMANCTL] Service name empty.\n");
continue;
@ -523,37 +535,39 @@ static void connmanctl_get_connected_servicename(
connmanctl services %s | \
grep \"^ State = \\(online\\|ready\\)\" | \
wc -l",
temp);
tmp);
service_file = popen(connman->command, "r");
fgets(ln, sizeof(ln), service_file);
ln_size = strlen(ln) - 1;
ln_len = strlen(ln) - 1;
if (ln[ln_size] == '\n')
ln[ln_size] = '\0';
if (ln[ln_len] == '\n')
ln[ln_len] = '\0';
pclose(service_file);
RARCH_LOG("[CONNMANCTL] Service: \"%s\", status: \"%s\"\n",
temp, ln);
tmp, ln);
if (ln[0] == '1')
{
size_t _len;
pclose(command_file);
strlcpy(servicename, temp, buffersize);
_len = strlcpy(s, tmp, len);
free(temp);
free(tmp);
RARCH_LOG("[CONNMANCTL] Service \"%s\" considered as currently online\n",
servicename);
s);
return;
return _len;
}
}
pclose(command_file);
return 0;
}
static void connmanctl_tether_start_stop(void *data, bool start, char* configfile)
@ -580,14 +594,15 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
if (start) /* we want to start tethering */
{
size_t __len;
RARCH_LOG("[CONNMANCTL] Tether start stop: request to start access point\n");
if (connmanctl_tether_status(connman)) /* check if already tethering and bail out if so */
{
const char *_msg = msg_hash_to_str(MSG_LOCALAP_ALREADY_RUNNING);
RARCH_LOG("[CONNMANCTL] Tether start stop: AP already running\n");
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_ALREADY_RUNNING),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
}
@ -599,12 +614,12 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
if (!(command_file = fopen(configfile, "w")))
{
const char *_msg = msg_hash_to_str(MSG_LOCALAP_ERROR_CONFIG_CREATE);
RARCH_ERR("[CONNMANCTL] Tether start stop: cannot create config file \"%s\"\n",
configfile);
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_ERROR_CONFIG_CREATE),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_ERROR);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return;
}
@ -643,13 +658,13 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
while (fgets(ln, sizeof(ln), command_file))
{
size_t ln_size = strlen(ln) - 1;
size_t ln_len = strlen(ln) - 1;
i++;
if ((ln_size + 1) > 1)
if ((ln_len + 1) > 1)
{
if (ln[ln_size] == '\n')
ln[ln_size] = '\0';
if (ln[ln_len] == '\n')
ln[ln_len] = '\0';
if (i == 1)
{
@ -682,15 +697,14 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
if (!ap_name || !pass_key)
{
size_t _len;
RARCH_ERR("[CONNMANCTL] Tether start stop: APNAME or PASSWORD missing\n");
snprintf(ln, sizeof(ln),
_len = snprintf(ln, sizeof(ln),
msg_hash_to_str(MSG_LOCALAP_ERROR_CONFIG_PARSE),
configfile);
runloop_msg_queue_push(ln,
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_ERROR);
runloop_msg_queue_push(ln, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return;
}
@ -701,10 +715,11 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
if (strlen(ssid) != 0)
{
connmanctl_get_connected_servicename(connman, service, sizeof(service));
size_t service_len = connmanctl_get_connected_servicename(connman, service, sizeof(service));
if (strlen(service) != 0)
if (service_len != 0)
{
size_t _len;
/* disconnect from wi-fi network */
RARCH_LOG("[CONNMANCTL] Tether start stop: connected to SSID \"%s\", service \"%s\"\n",
ssid, service);
@ -728,9 +743,9 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
while (fgets(ln, sizeof(ln), command_file))
{
size_t ln_size = strlen(ln) - 1;
if (ln[ln_size] == '\n')
ln[ln_size] = '\0';
size_t ln_len = strlen(ln) - 1;
if (ln[ln_len] == '\n')
ln[ln_len] = '\0';
RARCH_LOG("[CONNMANCTL] Tether start stop: output: \"%s\"\n",
ln);
@ -738,9 +753,8 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
#ifdef HAVE_GFX_WIDGETS
if (!widgets_active)
#endif
runloop_msg_queue_push(ln, 1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(ln, ln_len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
pclose(command_file);
@ -749,32 +763,32 @@ static void connmanctl_tether_start_stop(void *data, bool start, char* configfil
}
}
snprintf(connman->command, sizeof(connman->command),
__len = snprintf(connman->command, sizeof(connman->command),
msg_hash_to_str(MSG_LOCALAP_STARTING),
ap_name, pass_key);
runloop_msg_queue_push(connman->command,
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(connman->command, __len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else /* we want to stop tethering */
{
const char *_msg;
RARCH_LOG("[CONNMANCTL] Tether start stop: request to stop access point\n");
if (!connmanctl_tether_status(connman)) /* check if not tethering and when not, bail out */
{
const char *__msg = msg_hash_to_str(MSG_LOCALAP_NOT_RUNNING);
RARCH_LOG("[CONNMANCTL] Tether start stop: access point is not running\n");
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_NOT_RUNNING),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(__msg, strlen(__msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
}
runloop_msg_queue_push(msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_LOCALAP_SWITCHING_OFF);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
RARCH_LOG("[CONNMANCTL] Tether start stop: calling tether_toggle()\n");

233
network/netplay/netplay_frontend.c
View File

@ -947,20 +947,20 @@ bool netplay_handshake_init(netplay_t *netplay,
uint32_t header[6];
uint32_t netplay_magic = 0;
int32_t ping = 0;
const char *dmsg = NULL;
const char *_msg = NULL;
RECV(header, sizeof(header[0]))
{
if (netplay->is_server)
{
dmsg = msg_hash_to_str(MSG_FAILED_TO_CONNECT_TO_CLIENT);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_FAILED_TO_CONNECT_TO_CLIENT);
RARCH_ERR("[Netplay] %s\n", _msg);
return false;
}
else
{
dmsg = msg_hash_to_str(MSG_FAILED_TO_CONNECT_TO_HOST);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_FAILED_TO_CONNECT_TO_HOST);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
}
}
@ -991,16 +991,16 @@ bool netplay_handshake_init(netplay_t *netplay,
case NETPLAY_MAGIC:
break;
case FULL_MAGIC:
dmsg = msg_hash_to_str(MSG_NETPLAY_HOST_FULL);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_HOST_FULL);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
case BANNED_MAGIC:
dmsg = msg_hash_to_str(MSG_NETPLAY_BANNED);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_BANNED);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
default:
dmsg = msg_hash_to_str(MSG_NETPLAY_NOT_RETROARCH);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_NOT_RETROARCH);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
}
}
@ -1009,14 +1009,14 @@ bool netplay_handshake_init(netplay_t *netplay,
{
if (netplay->is_server)
{
dmsg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_HEADER_FROM_CLIENT);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_HEADER_FROM_CLIENT);
RARCH_ERR("[Netplay] %s\n", _msg);
return false;
}
else
{
dmsg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_HEADER_FROM_HOST);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_HEADER_FROM_HOST);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
}
}
@ -1037,8 +1037,8 @@ bool netplay_handshake_init(netplay_t *netplay,
/* Send it so that a proper notification can be shown there. */
netplay_handshake_init_send(netplay, connection, 0);
dmsg = msg_hash_to_str(MSG_NETPLAY_OUT_OF_DATE);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_OUT_OF_DATE);
RARCH_ERR("[Netplay] %s\n", _msg);
return false;
}
@ -1057,8 +1057,8 @@ bool netplay_handshake_init(netplay_t *netplay,
if (connection->netplay_protocol < LOW_NETPLAY_PROTOCOL_VERSION ||
connection->netplay_protocol > HIGH_NETPLAY_PROTOCOL_VERSION)
{
dmsg = msg_hash_to_str(MSG_NETPLAY_OUT_OF_DATE);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_OUT_OF_DATE);
RARCH_ERR("[Netplay] %s\n", _msg);
goto error;
}
}
@ -1068,8 +1068,8 @@ bool netplay_handshake_init(netplay_t *netplay,
{
if (ntohl(header[1]) != netplay_platform_magic())
{
dmsg = msg_hash_to_str(MSG_NETPLAY_PLATFORM_DEPENDENT);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_PLATFORM_DEPENDENT);
RARCH_ERR("[Netplay] %s\n", _msg);
if (netplay->is_server)
return false;
@ -1080,8 +1080,8 @@ bool netplay_handshake_init(netplay_t *netplay,
{
if (netplay_endian_mismatch(netplay_platform_magic(), ntohl(header[1])))
{
dmsg = msg_hash_to_str(MSG_NETPLAY_ENDIAN_DEPENDENT);
RARCH_ERR("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_ENDIAN_DEPENDENT);
RARCH_ERR("[Netplay] %s\n", _msg);
if (netplay->is_server)
return false;
@ -1094,10 +1094,10 @@ bool netplay_handshake_init(netplay_t *netplay,
settings_t *settings = config_get_ptr();
/* We allow the connection but warn that this could cause issues. */
dmsg = msg_hash_to_str(MSG_NETPLAY_DIFFERENT_VERSIONS);
RARCH_WARN("[Netplay] %s\n", dmsg);
_msg = msg_hash_to_str(MSG_NETPLAY_DIFFERENT_VERSIONS);
RARCH_WARN("[Netplay] %s\n", _msg);
if (!netplay->is_server && settings->bools.notification_show_netplay_extra)
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -1135,7 +1135,7 @@ bool netplay_handshake_init(netplay_t *netplay,
return true;
error:
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
@ -1144,6 +1144,7 @@ error:
static void netplay_handshake_ready(netplay_t *netplay,
struct netplay_connection *connection)
{
size_t _len;
char msg[512];
settings_t *settings = config_get_ptr();
@ -1151,7 +1152,7 @@ static void netplay_handshake_ready(netplay_t *netplay,
{
unsigned slot = (unsigned)(connection - netplay->connections);
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_GOT_CONNECTION_FROM),
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_GOT_CONNECTION_FROM),
connection->nick);
RARCH_LOG("[Netplay] %s %u\n", msg_hash_to_str(MSG_CONNECTION_SLOT),
@ -1162,9 +1163,9 @@ static void netplay_handshake_ready(netplay_t *netplay,
}
else
{
size_t _len = strlcpy(msg, msg_hash_to_str(MSG_CONNECTED_TO),
_len = strlcpy(msg, msg_hash_to_str(MSG_CONNECTED_TO),
sizeof(msg));
snprintf(msg + _len, sizeof(msg) - _len, ": \"%s\"",
_len += snprintf(msg + _len, sizeof(msg) - _len, ": \"%s\"",
connection->nick);
}
@ -1174,7 +1175,7 @@ static void netplay_handshake_ready(netplay_t *netplay,
but not as useful to the server.
Let it be optional if server. */
if (!netplay->is_server || settings->bools.notification_show_netplay_extra)
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -1436,18 +1437,18 @@ static bool netplay_handshake_pre_nick(netplay_t *netplay,
ntohl(nick_buf.cmd[0]) != NETPLAY_CMD_NICK ||
ntohl(nick_buf.cmd[1]) != sizeof(nick_buf.nick))
{
const char *dmsg = NULL;
const char *_msg = NULL;
if (netplay->is_server)
dmsg = msg_hash_to_str(MSG_FAILED_TO_GET_NICKNAME_FROM_CLIENT);
_msg = msg_hash_to_str(MSG_FAILED_TO_GET_NICKNAME_FROM_CLIENT);
else
{
dmsg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_NICKNAME_FROM_HOST);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
_msg = msg_hash_to_str(MSG_FAILED_TO_RECEIVE_NICKNAME_FROM_HOST);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
RARCH_ERR("[Netplay] %s\n", dmsg);
RARCH_ERR("[Netplay] %s\n", _msg);
return false;
}
@ -1577,10 +1578,10 @@ static bool netplay_handshake_pre_info(netplay_t *netplay,
{
if (!netplay->is_server)
{
const char *dmsg =
const char *_msg =
msg_hash_to_str(MSG_NETPLAY_INCORRECT_PASSWORD);
RARCH_ERR("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
RARCH_ERR("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
}
@ -1631,10 +1632,10 @@ static bool netplay_handshake_pre_info(netplay_t *netplay,
info_buf.core_name, system->library_name))
{
/* Wrong core! */
const char *dmsg = msg_hash_to_str(MSG_NETPLAY_DIFFERENT_CORES);
RARCH_ERR("[Netplay] %s\n", dmsg);
const char *_msg = msg_hash_to_str(MSG_NETPLAY_DIFFERENT_CORES);
RARCH_ERR("[Netplay] %s\n", _msg);
if (!netplay->is_server)
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return false;
}
@ -1652,11 +1653,11 @@ static bool netplay_handshake_pre_info(netplay_t *netplay,
if (!string_is_equal_case_insensitive(
info_buf.core_version, my_core_version))
{
const char *dmsg = msg_hash_to_str(
const char *_msg = msg_hash_to_str(
MSG_NETPLAY_DIFFERENT_CORE_VERSIONS);
RARCH_WARN("[Netplay] %s\n", dmsg);
RARCH_WARN("[Netplay] %s\n", _msg);
if (!netplay->is_server && extra_notifications)
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
}
}
@ -1667,12 +1668,12 @@ static bool netplay_handshake_pre_info(netplay_t *netplay,
if (content_crc && ntohl(info_buf.content_crc) != content_crc)
{
/* Warning of a different severety when using netpacket interface */
const char *dmsg = msg_hash_to_str(
const char *_msg = msg_hash_to_str(
netplay->modus == NETPLAY_MODUS_CORE_PACKET_INTERFACE ?
MSG_CONTENT_NETPACKET_CRC32S_DIFFER : MSG_CONTENT_CRC32S_DIFFER);
RARCH_WARN("[Netplay] %s\n", dmsg);
RARCH_WARN("[Netplay] %s\n", _msg);
if (!netplay->is_server && extra_notifications)
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
}
@ -1754,9 +1755,9 @@ static bool netplay_handshake_pre_sync(netplay_t *netplay,
RECV(cmd, sizeof(cmd))
{
const char *dmsg = msg_hash_to_str(MSG_PING_TOO_HIGH);
RARCH_ERR("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
const char *_msg = msg_hash_to_str(MSG_PING_TOO_HIGH);
RARCH_ERR("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
}
@ -1859,14 +1860,15 @@ static bool netplay_handshake_pre_sync(netplay_t *netplay,
STRING_SAFE(new_nick, sizeof(new_nick));
if (!string_is_equal(new_nick, netplay->nick))
{
size_t _len;
char msg[512];
memcpy(netplay->nick, new_nick, sizeof(netplay->nick));
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_CHANGED_NICK), new_nick);
RARCH_LOG("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -4141,7 +4143,7 @@ static void netplay_hangup(netplay_t *netplay,
{
size_t i;
char msg[512];
const char *dmsg;
const char *_msg;
bool was_playing = false;
settings_t *settings = config_get_ptr();
@ -4159,14 +4161,14 @@ static void netplay_hangup(netplay_t *netplay,
snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_SERVER_NAMED_HANGUP),
connection->nick);
dmsg = msg;
_msg = msg;
}
else
dmsg = msg_hash_to_str(MSG_NETPLAY_SERVER_HANGUP);
_msg = msg_hash_to_str(MSG_NETPLAY_SERVER_HANGUP);
}
else
{
dmsg = msg_hash_to_str(MSG_NETPLAY_CLIENT_HANGUP);
_msg = msg_hash_to_str(MSG_NETPLAY_CLIENT_HANGUP);
#ifdef HAVE_PRESENCE
{
presence_userdata_t userdata;
@ -4182,12 +4184,12 @@ static void netplay_hangup(netplay_t *netplay,
networking_driver_st.core_netpacket_interface->disconnected
((uint16_t)(connection - netplay->connections + 1));
RARCH_LOG("[Netplay] %s\n", dmsg);
RARCH_LOG("[Netplay] %s\n", _msg);
/* This notification is really only important to the server if the client was playing.
* Let it be optional if server and the client wasn't playing. */
if (!netplay->is_server || was_playing ||
settings->bools.notification_show_netplay_extra)
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
socket_close(connection->fd);
@ -4571,7 +4573,7 @@ static void netplay_announce_play_spectate(netplay_t *netplay,
{
size_t _len;
char msg[512];
const char *dmsg = NULL;
const char *_msg = NULL;
switch (mode)
{
@ -4581,10 +4583,10 @@ static void netplay_announce_play_spectate(netplay_t *netplay,
snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_PLAYER_S_LEFT),
NETPLAY_NICK_LEN, nick);
dmsg = msg;
_msg = msg;
}
else
dmsg = msg_hash_to_str(MSG_NETPLAY_YOU_HAVE_LEFT_THE_GAME);
_msg = msg_hash_to_str(MSG_NETPLAY_YOU_HAVE_LEFT_THE_GAME);
break;
case NETPLAY_CONNECTION_PLAYING:
case NETPLAY_CONNECTION_SLAVE:
@ -4659,7 +4661,7 @@ static void netplay_announce_play_spectate(netplay_t *netplay,
strlcpy(msg + _len, ping_str, sizeof(msg) - _len);
}
dmsg = msg;
_msg = msg;
break;
}
default: /* wrong usage */
@ -4670,8 +4672,8 @@ static void netplay_announce_play_spectate(netplay_t *netplay,
rcheevos_spectating_changed();
#endif
RARCH_LOG("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
RARCH_LOG("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -4795,12 +4797,11 @@ static void netplay_handle_play_spectate(netplay_t *netplay,
}
else
{
const char *dmsg = msg_hash_to_str(
const char *_msg = msg_hash_to_str(
MSG_NETPLAY_CANNOT_PLAY_NOT_AVAILABLE);
RARCH_LOG("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return;
}
@ -4860,12 +4861,11 @@ static void netplay_handle_play_spectate(netplay_t *netplay,
}
else
{
const char *dmsg = msg_hash_to_str(
const char *_msg = msg_hash_to_str(
MSG_NETPLAY_CANNOT_PLAY_NO_SLOTS);
RARCH_LOG("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return;
}
@ -5085,7 +5085,7 @@ static void netplay_show_chat(netplay_t *netplay, const char *nick, const char *
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-truncation"
#endif
snprintf(formatted_chat, sizeof(formatted_chat), "%s: %s", nick, msg);
size_t _len = snprintf(formatted_chat, sizeof(formatted_chat), "%s: %s", nick, msg);
#ifdef GEKKO
#pragma GCC diagnostic pop
#endif
@ -5109,7 +5109,7 @@ static void netplay_show_chat(netplay_t *netplay, const char *nick, const char *
}
else
#endif
runloop_msg_queue_push(formatted_chat, 1, NETPLAY_CHAT_FRAME_TIME, false,
runloop_msg_queue_push(formatted_chat, _len, 1, NETPLAY_CHAT_FRAME_TIME, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -5849,7 +5849,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
case NETPLAY_CMD_MODE_REFUSED:
{
uint32_t reason;
const char *dmsg = NULL;
const char *_msg = NULL;
if (netplay->is_server)
{
@ -5870,20 +5870,20 @@ static bool netplay_get_cmd(netplay_t *netplay,
switch (reason)
{
case NETPLAY_CMD_MODE_REFUSED_REASON_UNPRIVILEGED:
dmsg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_UNPRIVILEGED);
_msg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_UNPRIVILEGED);
break;
case NETPLAY_CMD_MODE_REFUSED_REASON_NO_SLOTS:
dmsg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_NO_SLOTS);
_msg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_NO_SLOTS);
break;
case NETPLAY_CMD_MODE_REFUSED_REASON_NOT_AVAILABLE:
dmsg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_NOT_AVAILABLE);
_msg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY_NOT_AVAILABLE);
break;
default:
dmsg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY);
_msg = msg_hash_to_str(MSG_NETPLAY_CANNOT_PLAY);
}
RARCH_LOG("[Netplay] %s\n", dmsg);
runloop_msg_queue_push(dmsg, 1, 180, false, NULL,
RARCH_LOG("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#ifdef HAVE_CHEEVOS
@ -6216,6 +6216,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
case NETPLAY_CMD_PAUSE:
{
size_t _len;
char msg[512], nick[NETPLAY_NICK_LEN];
NETPLAY_ASSERT_MODUS(NETPLAY_MODUS_INPUT_FRAME_SYNC);
@ -6244,7 +6245,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
}
/* Inform peers */
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_PEER_PAUSED), connection->nick);
netplay_send_raw_cmd_all(netplay, connection, NETPLAY_CMD_PAUSE,
connection->nick, sizeof(connection->nick));
@ -6256,7 +6257,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
else
{
STRING_SAFE(nick, sizeof(nick));
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_NETPLAY_PEER_PAUSED), nick);
}
@ -6264,7 +6265,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay->remote_paused = true;
RARCH_LOG("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
break;
}
@ -6650,17 +6651,17 @@ static void netplay_announce_nat_traversal(netplay_t *netplay,
if (!getnameinfo_retro((struct sockaddr*)addr, sizeof(*addr),
host, sizeof(host), port, sizeof(port),
NI_NUMERICHOST | NI_NUMERICSERV))
snprintf(msg + _len, sizeof(msg) - _len, ": %s:%s", host, port);
_len += snprintf(msg + _len, sizeof(msg) - _len, ": %s:%s", host, port);
RARCH_LOG("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
{
const char *msg = msg_hash_to_str(MSG_PRIVATE_OR_SHARED_ADDRESS);
RARCH_WARN("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 600, false, NULL,
runloop_msg_queue_push(msg, strlen(msg), 1, 600, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -6668,7 +6669,7 @@ static void netplay_announce_nat_traversal(netplay_t *netplay,
{
const char *msg = msg_hash_to_str(MSG_UPNP_FAILED);
RARCH_ERR("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, strlen(msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -6697,7 +6698,7 @@ static int init_tcp_connection(netplay_t *netplay, const struct addrinfo *addr,
{
char msg[512];
char host[256], port[6];
const char *dmsg = NULL;
const char *_msg = NULL;
int fd = socket(addr->ai_family, addr->ai_socktype,
addr->ai_protocol);
@ -6727,10 +6728,10 @@ static int init_tcp_connection(netplay_t *netplay, const struct addrinfo *addr,
snprintf(msg, sizeof(msg),
"Failed to connect to host %s on port %s.",
host, port);
dmsg = msg;
_msg = msg;
}
else
dmsg = "Failed to connect to host.";
_msg = "Failed to connect to host.";
}
else if (is_mitm)
{
@ -6770,7 +6771,7 @@ static int init_tcp_connection(netplay_t *netplay, const struct addrinfo *addr,
}
}
dmsg = "Failed to create a tunnel session.";
_msg = "Failed to create a tunnel session.";
}
else
{
@ -6781,10 +6782,10 @@ static int init_tcp_connection(netplay_t *netplay, const struct addrinfo *addr,
snprintf(msg, sizeof(msg),
"Failed to connect to relay server %s on port %s.",
host, port);
dmsg = msg;
_msg = msg;
}
else
dmsg = "Failed to connect to relay server.";
_msg = "Failed to connect to relay server.";
}
}
else
@ -6814,17 +6815,17 @@ static int init_tcp_connection(netplay_t *netplay, const struct addrinfo *addr,
snprintf(msg, sizeof(msg),
"Failed to bind port %s.",
port);
dmsg = msg;
_msg = msg;
}
else
dmsg = "Failed to bind port.";
_msg = "Failed to bind port.";
}
}
socket_close(fd);
if (dmsg)
RARCH_ERR("[Netplay] %s\n", dmsg);
if (_msg)
RARCH_ERR("[Netplay] %s\n", _msg);
return -1;
}
@ -8280,9 +8281,10 @@ static void netplay_announce_cb(retro_task_t *task, void *task_data,
/* Warn only on the first announce. */
if (!host_room->connectable && first)
{
const char *_msg = msg_hash_to_str(MSG_ROOM_NOT_CONNECTABLE);
RARCH_WARN("[Netplay] %s\n", msg_hash_to_str(MSG_ROOM_NOT_CONNECTABLE));
runloop_msg_queue_push(msg_hash_to_str(MSG_ROOM_NOT_CONNECTABLE), 1, 180,
false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#ifdef HAVE_PRESENCE
@ -8765,14 +8767,14 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
if (net_st->core_netpacket_interface)
modus = NETPLAY_MODUS_CORE_PACKET_INTERFACE;
if ((!core_info_current_supports_netplay() ||
serialization_quirks & (RETRO_SERIALIZATION_QUIRK_INCOMPLETE |
RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION))
if ((!core_info_current_supports_netplay()
|| serialization_quirks & (RETRO_SERIALIZATION_QUIRK_INCOMPLETE
| RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION))
&& modus != NETPLAY_MODUS_CORE_PACKET_INTERFACE)
{
const char *_msg = msg_hash_to_str(MSG_NETPLAY_UNSUPPORTED);
RARCH_ERR("[Netplay] %s\n", msg_hash_to_str(MSG_NETPLAY_UNSUPPORTED));
runloop_msg_queue_push(
msg_hash_to_str(MSG_NETPLAY_UNSUPPORTED), 0, 180, false, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto failure;
}
@ -8847,6 +8849,7 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
if (netplay->is_server)
{
const char *_msg;
if (mitm)
{
int flen = 0;
@ -8869,8 +8872,8 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
netplay->next_announce =
cpu_features_get_time_usec() + NETPLAY_ANNOUNCE_AFTER;
runloop_msg_queue_push(
msg_hash_to_str(MSG_WAITING_FOR_CLIENT), 0, 180, false, NULL,
_msg = msg_hash_to_str(MSG_WAITING_FOR_CLIENT);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
netplay->self_mode = NETPLAY_CONNECTION_SPECTATING;
@ -8902,10 +8905,12 @@ failure:
| NET_DRIVER_ST_FLAG_NETPLAY_CLIENT_DEFERRED);
deinit_netplay();
RARCH_ERR("[Netplay] %s\n", msg_hash_to_str(MSG_NETPLAY_FAILED));
runloop_msg_queue_push(
msg_hash_to_str(MSG_NETPLAY_FAILED), 0, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_NETPLAY_FAILED);
RARCH_ERR("[Netplay] %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
return false;
}

4
pkg/apple/CocoaView+Utilities.swift
View File

@ -7,7 +7,7 @@
//
extension CocoaView {
// A native swift wrapper around displaying notifications
@objc func showRetroArchNotification(
title: String? = nil,
@ -23,6 +23,6 @@ extension CocoaView {
}
return nil
}()
runloop_msg_queue_push(messageCString, 1, 100, true, titleCString, icon, category)
runloop_msg_queue_push(messageCString, strlen(messageCString), 1, 100, true, titleCString, icon, category)
}
}

17
pkg/apple/HelperBar/CocoaView+HelperBar.swift
View File

@ -21,7 +21,7 @@ extension CocoaView {
@objc func setupHelperBar() {
let helperVC = HelperBarViewController()
let viewModel = HelperBarViewModel(delegate: helperVC, actionDelegate: self)
helperVC.viewModel = viewModel
helperVC.viewModel = viewModel
addChild(helperVC)
helperVC.didMove(toParent: self)
helperBarView = helperVC.view
@ -40,17 +40,18 @@ extension CocoaView: HelperBarActionDelegate {
func keyboardButtonTapped() {
toggleCustomKeyboard()
}
func mouseButtonTapped() {
mouseHandler.enabled.toggle()
let messageKey = mouseHandler.enabled ? MSG_IOS_TOUCH_MOUSE_ENABLED : MSG_IOS_TOUCH_MOUSE_DISABLED
let message = msg_hash_to_str(messageKey)
runloop_msg_queue_push(message, 1, 100, true, nil, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO)
runloop_msg_queue_push(message, strlen(message), 1, 100, true, nil,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO)
}
func helpButtonTapped() {
}
func orientationLockButtonTapped() {
#if os(iOS)
shouldLockCurrentInterfaceOrientation.toggle()
@ -63,15 +64,15 @@ extension CocoaView: HelperBarActionDelegate {
}
#endif
}
var isKeyboardEnabled: Bool {
!keyboardController.view.isHidden
}
var isMouseEnabled: Bool {
mouseHandler.enabled
}
var isOrientationLocked: Bool {
shouldLockCurrentInterfaceOrientation
}

242
retroarch.c
View File

@ -418,7 +418,10 @@ bool driver_location_start(void)
if (location_allow)
return location_st->driver->start(location_st->data);
runloop_msg_queue_push("Location is explicitly disabled.\n",
/* TODO/FIXME - localize */
runloop_msg_queue_push(
"Location is explicitly disabled.\n",
STRLEN_CONST("Location is explicitly disabled.\n"),
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -3132,9 +3135,9 @@ bool command_event(enum event_command cmd, void *data)
{
if (!core_info_current_supports_runahead())
{
runloop_msg_queue_push(msg_hash_to_str(MSG_RUNAHEAD_CORE_DOES_NOT_SUPPORT_RUNAHEAD),
1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_RUNAHEAD_CORE_DOES_NOT_SUPPORT_RUNAHEAD);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
break;
}
@ -3144,15 +3147,16 @@ bool command_event(enum event_command cmd, void *data)
if (settings->bools.run_ahead_enabled)
{
char msg[128];
size_t _len;
if (settings->bools.run_ahead_secondary_instance)
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_RUNAHEAD_ENABLED_WITH_SECOND_INSTANCE),
settings->uints.run_ahead_frames);
else
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_RUNAHEAD_ENABLED),
settings->uints.run_ahead_frames);
runloop_msg_queue_push(msg, 1, 100, false,
runloop_msg_queue_push(msg, _len, 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
@ -3161,9 +3165,11 @@ bool command_event(enum event_command cmd, void *data)
preempt_deinit(runloop_st);
}
else
runloop_msg_queue_push(msg_hash_to_str(MSG_RUNAHEAD_DISABLED),
1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_RUNAHEAD_DISABLED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
#ifdef HAVE_MENU
/* Update menu */
@ -3187,17 +3193,18 @@ bool command_event(enum event_command cmd, void *data)
settings->bools.run_ahead_hide_warnings = old_warn;
if (old_inited && !runloop_st->preempt_data)
runloop_msg_queue_push(msg_hash_to_str(MSG_PREEMPT_DISABLED),
1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_PREEMPT_DISABLED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else if (runloop_st->preempt_data)
{
char msg[128];
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_PREEMPT_ENABLED),
size_t _len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_PREEMPT_ENABLED),
settings->uints.run_ahead_frames);
runloop_msg_queue_push(
msg, 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
/* Disable runahead */
settings->bools.run_ahead_enabled = false;
@ -3244,25 +3251,27 @@ bool command_event(enum event_command cmd, void *data)
if (video_driver_get_video_output_size(&width, &height, desc, sizeof(desc)))
{
size_t _len;
char msg[128];
video_driver_set_video_mode(width, height, true);
if (width == 0 || height == 0)
strlcpy(msg, msg_hash_to_str(MSG_SCREEN_RESOLUTION_DEFAULT), sizeof(msg));
_len = strlcpy(msg, msg_hash_to_str(MSG_SCREEN_RESOLUTION_DEFAULT), sizeof(msg));
else
{
msg[0] = '\0';
if (!string_is_empty(desc))
snprintf(msg, sizeof(msg),
_len = snprintf(msg, sizeof(msg),
msg_hash_to_str(MSG_SCREEN_RESOLUTION_DESC),
width, height, desc);
else
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_NO_DESC),
_len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_SCREEN_RESOLUTION_NO_DESC),
width, height);
}
runloop_msg_queue_push(msg, 1, 100, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
#endif
@ -3326,7 +3335,9 @@ bool command_event(enum event_command cmd, void *data)
#ifdef HAVE_CHEEVOS
if (rcheevos_hardcore_active())
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CHEEVOS_LOAD_STATE_PREVENTED_BY_HARDCORE_MODE), 0, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
const char *_msg = msg_hash_to_str(MSG_CHEEVOS_LOAD_STATE_PREVENTED_BY_HARDCORE_MODE);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
return false;
}
#endif
@ -3374,34 +3385,38 @@ bool command_event(enum event_command cmd, void *data)
#endif
break;
case CMD_EVENT_RESET:
RARCH_LOG("[Core]: %s.\n", msg_hash_to_str(MSG_RESET));
runloop_msg_queue_push(msg_hash_to_str(MSG_RESET), 1, 120, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_RESET);
RARCH_LOG("[Core]: %s.\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
core_reset();
core_reset();
#ifdef HAVE_CHEEVOS
#ifdef HAVE_GFX_WIDGETS
rcheevos_reset_game(dispwidget_get_ptr()->active);
rcheevos_reset_game(dispwidget_get_ptr()->active);
#else
rcheevos_reset_game(false);
rcheevos_reset_game(false);
#endif
#endif
#ifdef HAVE_NETWORKING
netplay_driver_ctl(RARCH_NETPLAY_CTL_RESET, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_RESET, NULL);
#endif
/* Recalibrate frame delay target */
if (settings->bools.video_frame_delay_auto)
video_st->frame_delay_target = 0;
/* Recalibrate frame delay target */
if (settings->bools.video_frame_delay_auto)
video_st->frame_delay_target = 0;
/* Run a few frames to blank core output while paused */
if (runloop_st->flags & RUNLOOP_FLAG_PAUSED)
{
runloop_st->flags &= ~RUNLOOP_FLAG_PAUSED;
runloop_st->run_frames_and_pause = 8;
}
/* Run a few frames to blank core output while paused */
if (runloop_st->flags & RUNLOOP_FLAG_PAUSED)
{
runloop_st->flags &= ~RUNLOOP_FLAG_PAUSED;
runloop_st->run_frames_and_pause = 8;
}
#if HAVE_RUNAHEAD
command_event(CMD_EVENT_PREEMPT_RESET_BUFFER, NULL);
command_event(CMD_EVENT_PREEMPT_RESET_BUFFER, NULL);
#endif
}
return false;
case CMD_EVENT_PLAY_REPLAY:
{
@ -3420,12 +3435,11 @@ bool command_event(enum event_command cmd, void *data)
res = movie_start_playback(input_st, replay_path);
if (!res)
{
const char *movie_fail_str =
const char *_msg =
msg_hash_to_str(MSG_FAILED_TO_LOAD_MOVIE_FILE);
runloop_msg_queue_push(movie_fail_str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", movie_fail_str);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", _msg);
}
return res;
#else
@ -3454,12 +3468,10 @@ bool command_event(enum event_command cmd, void *data)
configuration_set_int(settings, settings->ints.replay_slot, replay_slot);
if (!res)
{
const char *movie_rec_fail_str =
msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD);
runloop_msg_queue_push(movie_rec_fail_str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", movie_rec_fail_str);
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", _msg);
}
return res;
#else
@ -3857,7 +3869,7 @@ bool command_event(enum event_command cmd, void *data)
audio_st->mute_enable);
else
#endif
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, strlen(msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
break;
@ -3918,9 +3930,11 @@ bool command_event(enum event_command cmd, void *data)
else if (!string_is_empty(settings->paths.path_osk_overlay))
input_st->flags |= INP_FLAG_KB_LINEFEED_ENABLE;
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_OSK_OVERLAY_NOT_SET), 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_OSK_OVERLAY_NOT_SET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
command_event(CMD_EVENT_OVERLAY_INIT, NULL);
@ -4290,11 +4304,11 @@ bool command_event(enum event_command cmd, void *data)
#endif
case CMD_EVENT_SHUTDOWN:
#if defined(__linux__) && !defined(ANDROID)
const char *_msg = msg_hash_to_str(MSG_VALUE_SHUTTING_DOWN);
if (settings->bools.config_save_on_exit)
{
command_event(CMD_EVENT_MENU_SAVE_CURRENT_CONFIG, NULL);
}
runloop_msg_queue_push(msg_hash_to_str(MSG_VALUE_SHUTTING_DOWN), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_LAKKA
system("nohup /usr/bin/lakka-shutdown.sh 2>&1 >/dev/null & exit");
#else
@ -4305,11 +4319,11 @@ bool command_event(enum event_command cmd, void *data)
break;
case CMD_EVENT_REBOOT:
#if defined(__linux__) && !defined(ANDROID)
const char *_msg = msg_hash_to_str(MSG_VALUE_REBOOTING);
if (settings->bools.config_save_on_exit)
{
command_event(CMD_EVENT_MENU_SAVE_CURRENT_CONFIG, NULL);
}
runloop_msg_queue_push(msg_hash_to_str(MSG_VALUE_REBOOTING), 1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_LAKKA
system("nohup /usr/bin/lakka-reboot.sh 2>&1 >/dev/null & exit");
#else
@ -4340,11 +4354,11 @@ bool command_event(enum event_command cmd, void *data)
struct string_list *str_list = (struct string_list*)data;
/* Check whether favourites playlist is at capacity */
if (playlist_size(g_defaults.content_favorites) >=
playlist_capacity(g_defaults.content_favorites))
if ( playlist_size(g_defaults.content_favorites)
>= playlist_capacity(g_defaults.content_favorites))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_ADD_TO_FAVORITES_FAILED), 1, 180, true, NULL,
const char *_msg = msg_hash_to_str(MSG_ADD_TO_FAVORITES_FAILED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return true;
}
@ -4366,6 +4380,7 @@ bool command_event(enum event_command cmd, void *data)
/* Write playlist entry */
if (playlist_push(g_defaults.content_favorites, &entry))
{
const char *_msg;
enum playlist_sort_mode current_sort_mode =
playlist_get_sort_mode(g_defaults.content_favorites);
@ -4376,8 +4391,8 @@ bool command_event(enum event_command cmd, void *data)
playlist_qsort(g_defaults.content_favorites);
playlist_write_file(g_defaults.content_favorites);
runloop_msg_queue_push(
msg_hash_to_str(MSG_ADDED_TO_FAVORITES), 1, 180, true, NULL,
_msg = msg_hash_to_str(MSG_ADDED_TO_FAVORITES);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#if TARGET_OS_TV
update_topshelf();
@ -4424,11 +4439,11 @@ bool command_event(enum event_command cmd, void *data)
playlist = playlist_init(&playlist_config);
/* Check whether favourites playlist is at capacity */
if (playlist_size(playlist) >=
playlist_capacity(playlist))
if ( playlist_size(playlist)
>= playlist_capacity(playlist))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_ADD_TO_PLAYLIST_FAILED), 1, 180, true, NULL,
const char *_msg = msg_hash_to_str(MSG_ADD_TO_PLAYLIST_FAILED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return true;
}
@ -4436,6 +4451,7 @@ bool command_event(enum event_command cmd, void *data)
/* Write playlist entry */
if (playlist_push(playlist, &entry))
{
const char *_msg = NULL;
enum playlist_sort_mode current_sort_mode =
playlist_get_sort_mode(playlist);
@ -4446,8 +4462,8 @@ bool command_event(enum event_command cmd, void *data)
playlist_qsort(playlist);
playlist_write_file(playlist);
runloop_msg_queue_push(
msg_hash_to_str(MSG_ADDED_TO_PLAYLIST), 1, 180, true, NULL,
_msg = msg_hash_to_str(MSG_ADDED_TO_PLAYLIST);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
@ -4461,6 +4477,7 @@ bool command_event(enum event_command cmd, void *data)
}
case CMD_EVENT_RESET_CORE_ASSOCIATION:
{
const char *_msg;
const char *core_name = "DETECT";
const char *core_path = "DETECT";
size_t *playlist_index = (size_t*)data;
@ -4486,8 +4503,8 @@ bool command_event(enum event_command cmd, void *data)
menu_st->userdata, i);
#endif
runloop_msg_queue_push(
msg_hash_to_str(MSG_RESET_CORE_ASSOCIATION), 1, 180, true, NULL,
_msg = msg_hash_to_str(MSG_RESET_CORE_ASSOCIATION);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
break;
}
@ -4817,17 +4834,15 @@ bool command_event(enum event_command cmd, void *data)
else if (!task_push_netplay_content_reload(NULL))
{
#ifdef HAVE_DYNAMIC
const char *_msg = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED);
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_SERVER, NULL);
runloop_msg_queue_push(
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED),
1, 480, true, NULL,
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#else
runloop_msg_queue_push(
msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED),
1, 480, true, NULL,
const char *_msg = msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#endif
@ -4974,10 +4989,11 @@ bool command_event(enum event_command cmd, void *data)
return success;
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case CMD_EVENT_DISK_EJECT_TOGGLE:
@ -5014,10 +5030,11 @@ bool command_event(enum event_command cmd, void *data)
#endif
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case CMD_EVENT_DISK_NEXT:
@ -5041,10 +5058,11 @@ bool command_event(enum event_command cmd, void *data)
disk_control_set_index_next(&sys_info->disk_control, verbose);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case CMD_EVENT_DISK_PREV:
@ -5068,10 +5086,11 @@ bool command_event(enum event_command cmd, void *data)
disk_control_set_index_prev(&sys_info->disk_control, verbose);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case CMD_EVENT_DISK_INDEX:
@ -5087,10 +5106,11 @@ bool command_event(enum event_command cmd, void *data)
if (disk_control_enabled(&sys_info->disk_control))
disk_control_set_index(&sys_info->disk_control, *index, false);
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 120, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case CMD_EVENT_RUMBLE_STOP:
@ -5249,13 +5269,15 @@ bool command_event(enum event_command cmd, void *data)
| INP_FLAG_KB_MAPPING_BLOCKED);
if (show_message)
runloop_msg_queue_push(
{
const char *_msg =
input_st->game_focus_state.enabled ?
msg_hash_to_str(MSG_GAME_FOCUS_ON) :
msg_hash_to_str(MSG_GAME_FOCUS_OFF),
1, 60, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
msg_hash_to_str(MSG_GAME_FOCUS_OFF);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
RARCH_LOG("[Input]: %s => %s\n",
"Game Focus",
@ -5392,12 +5414,14 @@ bool command_event(enum event_command cmd, void *data)
}
break;
case CMD_EVENT_VRR_RUNLOOP_TOGGLE:
settings->bools.vrr_runloop_enable = !(settings->bools.vrr_runloop_enable);
runloop_msg_queue_push(
msg_hash_to_str(
{
const char *_msg = msg_hash_to_str(
settings->bools.vrr_runloop_enable ? MSG_VRR_RUNLOOP_ENABLED
: MSG_VRR_RUNLOOP_DISABLED),
1, 100, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
: MSG_VRR_RUNLOOP_DISABLED);
settings->bools.vrr_runloop_enable = !(settings->bools.vrr_runloop_enable);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
break;
case CMD_EVENT_NONE:
return false;

73
runahead.c
View File

@ -1174,11 +1174,12 @@ void runahead_run(void *data,
if (!runahead_create(runloop_st))
{
const char *runahead_failed_str =
const char *_msg =
msg_hash_to_str(MSG_RUNAHEAD_CORE_DOES_NOT_SUPPORT_SAVESTATES);
if (!runahead_hide_warnings)
runloop_msg_queue_push(runahead_failed_str, 0, 2 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 2 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
goto force_input_dirty;
}
}
@ -1226,10 +1227,11 @@ void runahead_run(void *data,
{
if (!runahead_save_state(runloop_st))
{
const char *runahead_failed_str =
const char *_msg =
msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_SAVE_STATE);
runloop_msg_queue_push(runahead_failed_str, 0, 3 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
return;
}
}
@ -1238,10 +1240,10 @@ void runahead_run(void *data,
{
if (!runahead_load_state(runloop_st))
{
const char *runahead_failed_str =
msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_LOAD_STATE);
runloop_msg_queue_push(runahead_failed_str, 0, 3 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
const char *_msg = msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_LOAD_STATE);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
return;
}
}
@ -1252,12 +1254,13 @@ void runahead_run(void *data,
#if HAVE_DYNAMIC
if (!secondary_core_ensure_exists(runloop_st, config_get_ptr()))
{
const char *runahead_failed_str =
const char *_msg =
msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_CREATE_SECONDARY_INSTANCE);
runahead_secondary_core_destroy(runloop_st);
runloop_st->flags &= ~RUNLOOP_FLAG_RUNAHEAD_SECONDARY_CORE_AVAILABLE;
runloop_msg_queue_push(runahead_failed_str, 0, 3 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
goto force_input_dirty;
}
@ -1276,19 +1279,19 @@ void runahead_run(void *data,
if (!runahead_save_state(runloop_st))
{
const char *runahead_failed_str =
msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_SAVE_STATE);
runloop_msg_queue_push(runahead_failed_str, 0, 3 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
const char *_msg = msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_SAVE_STATE);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
return;
}
if (!runahead_load_state_secondary(runloop_st, settings))
{
const char *runahead_failed_str =
msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_LOAD_STATE);
runloop_msg_queue_push(runahead_failed_str, 0, 3 * 60, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", runahead_failed_str);
const char *_msg = msg_hash_to_str(MSG_RUNAHEAD_FAILED_TO_LOAD_STATE);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 3 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Run-Ahead]: %s\n", _msg);
return;
}
@ -1434,7 +1437,7 @@ bool preempt_init(void *data)
{
runloop_state_t *runloop_st = (runloop_state_t*)data;
settings_t *settings = config_get_ptr();
const char *failed_str = NULL;
const char *_msg = NULL;
if ( runloop_st->preempt_data
|| !settings->bools.preemptive_frames_enable
@ -1445,7 +1448,7 @@ bool preempt_init(void *data)
/* Check if supported - same requirements as runahead */
if (!core_info_current_supports_runahead())
{
failed_str = msg_hash_to_str(MSG_PREEMPT_CORE_DOES_NOT_SUPPORT_PREEMPT);
_msg = msg_hash_to_str(MSG_PREEMPT_CORE_DOES_NOT_SUPPORT_PREEMPT);
goto error;
}
@ -1459,7 +1462,7 @@ bool preempt_init(void *data)
runloop_st->current_core.retro_run();
/* Allocate - same 'frames' setting as runahead */
if ((failed_str = preempt_allocate(runloop_st,
if ((_msg = preempt_allocate(runloop_st,
settings->uints.run_ahead_frames)))
goto error;
@ -1474,10 +1477,9 @@ error:
preempt_deinit(runloop_st);
if (!settings->bools.run_ahead_hide_warnings)
runloop_msg_queue_push(
failed_str, 0, 2 * 60, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Preemptive Frames]: %s\n", failed_str);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 2 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_WARN("[Preemptive Frames]: %s\n", _msg);
return false;
}
@ -1616,7 +1618,7 @@ void preempt_run(preempt_t *preempt, void *data)
{
runloop_state_t *runloop_st = (runloop_state_t*)data;
struct retro_core_t *current_core = &runloop_st->current_core;
const char *failed_str = NULL;
const char *_msg = NULL;
settings_t *settings = config_get_ptr();
audio_driver_state_t *audio_st = audio_state_get_ptr();
video_driver_state_t *video_st = video_state_get_ptr();
@ -1636,7 +1638,7 @@ void preempt_run(preempt_t *preempt, void *data)
if (!current_core->retro_unserialize(
preempt->buffer[preempt->start_ptr], preempt->state_size))
{
failed_str = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_LOAD_STATE);
_msg = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_LOAD_STATE);
goto error;
}
@ -1648,7 +1650,7 @@ void preempt_run(preempt_t *preempt, void *data)
if (!current_core->retro_serialize(
preempt->buffer[preempt->replay_ptr], preempt->state_size))
{
failed_str = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_SAVE_STATE);
_msg = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_SAVE_STATE);
goto error;
}
@ -1664,7 +1666,7 @@ void preempt_run(preempt_t *preempt, void *data)
if (!current_core->retro_serialize(
preempt->buffer[preempt->start_ptr], preempt->state_size))
{
failed_str = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_SAVE_STATE);
_msg = msg_hash_to_str(MSG_PREEMPT_FAILED_TO_SAVE_STATE);
goto error;
}
preempt->start_ptr = PREEMPT_NEXT_PTR(preempt->start_ptr);
@ -1684,10 +1686,9 @@ error:
preempt_deinit(runloop_st);
if (!settings->bools.run_ahead_hide_warnings)
runloop_msg_queue_push(
failed_str, 0, 2 * 60, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("[Preemptive Frames]: %s\n", failed_str);
runloop_msg_queue_push(_msg, strlen(_msg), 0, 2 * 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("[Preemptive Frames]: %s\n", _msg);
}
void runahead_clear_variables(void *data)

135
runloop.c
View File

@ -1351,7 +1351,7 @@ static void runloop_core_msg_queue_push(
/* Note: Do not flush the message queue here - a core
* may need to send multiple notifications simultaneously */
runloop_msg_queue_push(msg->msg,
runloop_msg_queue_push(msg->msg, strlen(msg->msg),
msg->priority, duration_frames,
false, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
category);
@ -1745,7 +1745,7 @@ bool runloop_environment_cb(unsigned cmd, void *data)
roundf((float)msg->frames / 60.0f * 1000.0f));
else
#endif
runloop_msg_queue_push(msg->msg, 3, msg->frames,
runloop_msg_queue_push(msg->msg, strlen(msg->msg), 3, msg->frames,
true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Environ]: SET_MESSAGE: %s\n", msg->msg);
@ -2466,10 +2466,9 @@ bool runloop_environment_cb(unsigned cmd, void *data)
if (recording_st->data)
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT),
2, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
if (recording_st->streaming_enable)
{
command_event(CMD_EVENT_STREAMING_TOGGLE, NULL);
@ -2705,10 +2704,9 @@ bool runloop_environment_cb(unsigned cmd, void *data)
* the recording. */
if (recording_st->data)
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT),
2, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_RESTARTING_RECORDING_DUE_TO_DRIVER_REINIT);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
if (recording_st->streaming_enable)
{
command_event(CMD_EVENT_STREAMING_TOGGLE, NULL);
@ -3692,12 +3690,10 @@ bool runloop_init_libretro_symbols(
path_get_realsize(RARCH_PATH_CORE)
)))
{
const char *failed_open_str =
msg_hash_to_str(MSG_FAILED_TO_OPEN_LIBRETRO_CORE);
RARCH_ERR("%s: \"%s\"\nError(s): %s\n", failed_open_str,
path, dylib_error());
runloop_msg_queue_push(failed_open_str,
1, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_OPEN_LIBRETRO_CORE);
RARCH_ERR("%s: \"%s\"\nError(s): %s\n", _msg, path, dylib_error());
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return false;
}
lib_handle_local = runloop_st->lib_handle;
@ -4783,9 +4779,11 @@ void runloop_pause_checks(void)
#if defined(HAVE_GFX_WIDGETS)
if (!widgets_active)
#endif
runloop_msg_queue_push(msg_hash_to_str(MSG_PAUSED), 1,
1, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_PAUSED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 1, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (!is_idle)
video_driver_cached_frame();
@ -4884,6 +4882,7 @@ bool core_options_create_override(bool game_specific)
{
char options_path[PATH_MAX_LENGTH];
runloop_state_t *runloop_st = &runloop_state;
const char *_msg = NULL;
config_file_t *conf = NULL;
options_path[0] = '\0';
@ -4924,10 +4923,9 @@ bool core_options_create_override(bool game_specific)
goto error;
RARCH_LOG("[Core]: Core options file created successfully: \"%s\".\n", options_path);
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_OPTIONS_FILE_CREATED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_CORE_OPTIONS_FILE_CREATED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
path_set(RARCH_PATH_CORE_OPTIONS, options_path);
if (game_specific)
@ -4945,10 +4943,9 @@ bool core_options_create_override(bool game_specific)
return true;
error:
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_SAVING_CORE_OPTIONS_FILE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_msg = msg_hash_to_str(MSG_ERROR_SAVING_CORE_OPTIONS_FILE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
if (conf)
config_file_free(conf);
@ -5099,10 +5096,12 @@ bool core_options_remove_override(bool game_specific)
}
}
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_OPTIONS_FILE_REMOVED_SUCCESSFULLY),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_OPTIONS_FILE_REMOVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (conf)
config_file_free(conf);
@ -5110,10 +5109,11 @@ bool core_options_remove_override(bool game_specific)
return true;
error:
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_REMOVING_CORE_OPTIONS_FILE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_REMOVING_CORE_OPTIONS_FILE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (conf)
config_file_free(conf);
@ -5141,10 +5141,11 @@ void core_options_reset(void)
rcheevos_validate_config_settings();
#endif
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_OPTIONS_RESET),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_CORE_OPTIONS_RESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
void core_options_flush(void)
@ -5238,15 +5239,16 @@ void core_options_flush(void)
path_core_options ? path_core_options : "UNKNOWN");
}
snprintf(msg + _len, sizeof(msg) - _len, " \"%s\"",
_len += snprintf(msg + _len, sizeof(msg) - _len, " \"%s\"",
core_options_file);
runloop_msg_queue_push(
msg, 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
void runloop_msg_queue_push(const char *msg,
void runloop_msg_queue_push(
const char *msg,
size_t len,
unsigned prio, unsigned duration,
bool flush,
char *title,
@ -5281,6 +5283,7 @@ void runloop_msg_queue_push(const char *msg,
gfx_widgets_msg_queue_push(
NULL,
msg,
len,
roundf((float)duration / 60.0f * 1000.0f),
title,
icon,
@ -5677,15 +5680,14 @@ static enum runloop_state_enum runloop_check_state(
if (!trig_quit_key)
{
float target_hz = 0.0;
const char *_msg = msg_hash_to_str(MSG_PRESS_AGAIN_TO_QUIT);
float target_hz = 0.0;
runloop_environment_cb(
RETRO_ENVIRONMENT_GET_TARGET_REFRESH_RATE, &target_hz);
runloop_msg_queue_push(msg_hash_to_str(MSG_PRESS_AGAIN_TO_QUIT), 1,
QUIT_DELAY_USEC * target_hz / 1000000,
true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, QUIT_DELAY_USEC * target_hz / 1000000,
true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
@ -6156,7 +6158,7 @@ static enum runloop_state_enum runloop_check_state(
#endif
{
if (rewinding)
runloop_msg_queue_push(s, 0, t, true, NULL,
runloop_msg_queue_push(s, strlen(s), 0, t, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
@ -6454,8 +6456,11 @@ static enum runloop_state_enum runloop_check_state(
* status via OSD text for 1 frame every frame */
if ( (runloop_st->flags & RUNLOOP_FLAG_FASTMOTION)
&& settings->bools.notification_show_fast_forward)
runloop_msg_queue_push(
msg_hash_to_str(MSG_FAST_FORWARD), 1, 1, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_FAST_FORWARD);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 1, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
}
#if defined(HAVE_GFX_WIDGETS)
@ -6519,14 +6524,18 @@ static enum runloop_state_enum runloop_check_state(
*rewind_st = &runloop_st->rewind_st;
if (rewind_st->flags
& STATE_MGR_REWIND_ST_FLAG_FRAME_IS_REVERSED)
runloop_msg_queue_push(
msg_hash_to_str(MSG_SLOW_MOTION_REWIND), 1, 1, false, NULL,
{
const char *_msg = msg_hash_to_str(MSG_SLOW_MOTION_REWIND);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 1, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
#endif
runloop_msg_queue_push(
msg_hash_to_str(MSG_SLOW_MOTION), 1, 1, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(MSG_SLOW_MOTION);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 1, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
}
@ -6579,14 +6588,14 @@ static enum runloop_state_enum runloop_check_state(
": %d", settings->ints.state_slot);
if (cur_state_slot < 0)
strlcpy(msg + _len, " (Auto)", sizeof(msg) - _len);
_len += strlcpy(msg + _len, " (Auto)", sizeof(msg) - _len);
#ifdef HAVE_GFX_WIDGETS
if (dispwidget_get_ptr()->active)
gfx_widget_set_generic_message(msg, 1000);
else
#endif
runloop_msg_queue_push(msg, 2, 60, true, NULL,
runloop_msg_queue_push(msg, _len, 2, 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[State]: %s\n", msg);
@ -6639,14 +6648,14 @@ static enum runloop_state_enum runloop_check_state(
": %d", settings->ints.replay_slot);
if (cur_replay_slot < 0)
strlcpy(msg + _len, " (Auto)", sizeof(msg) - _len);
_len += strlcpy(msg + _len, " (Auto)", sizeof(msg) - _len);
#ifdef HAVE_GFX_WIDGETS
if (dispwidget_get_ptr()->active)
gfx_widget_set_generic_message(msg, 1000);
else
#endif
runloop_msg_queue_push(msg, 2, 60, true, NULL,
runloop_msg_queue_push(msg, _len, 2, 60, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Replay]: %s\n", msg);
@ -7299,6 +7308,7 @@ void runloop_task_msg_queue_push(
gfx_widgets_msg_queue_push(
task,
msg,
strlen(msg),
duration,
NULL,
(enum message_queue_icon)MESSAGE_QUEUE_CATEGORY_INFO,
@ -7315,7 +7325,8 @@ void runloop_task_msg_queue_push(
}
else
#endif
runloop_msg_queue_push(msg, prio, duration, flush, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, strlen(msg), prio, duration, flush, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}

2
runloop.h
View File

@ -321,7 +321,7 @@ void runloop_path_fill_names(void);
**/
bool runloop_environment_cb(unsigned cmd, void *data);
void runloop_msg_queue_push(const char *msg,
void runloop_msg_queue_push(const char *msg, size_t len,
unsigned prio, unsigned duration,
bool flush,
char *title,

20
state_manager.c
View File

@ -655,7 +655,7 @@ void state_manager_event_deinit(
if (!rewind_st)
return;
restore_callbacks =
restore_callbacks =
(rewind_st->flags & STATE_MGR_REWIND_ST_FLAG_INIT_ATTEMPTED)
&& (rewind_st->state)
&& (current_core);
@ -717,13 +717,15 @@ bool state_manager_check_rewind(
if (!rewind_st->state)
{
if ((pressed
&& (!(rewind_st->flags
if ((pressed
&& (!(rewind_st->flags
& STATE_MGR_REWIND_ST_FLAG_HOTKEY_WAS_PRESSED)))
&& !core_info_current_supports_rewind())
runloop_msg_queue_push(msg_hash_to_str(MSG_REWIND_UNSUPPORTED),
1, 100, false, NULL,
{
const char *_msg = msg_hash_to_str(MSG_REWIND_UNSUPPORTED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (pressed)
rewind_st->flags |= STATE_MGR_REWIND_ST_FLAG_HOTKEY_WAS_PRESSED;
@ -817,16 +819,16 @@ bool state_manager_check_rewind(
{
if (current_core->retro_set_audio_sample)
current_core->retro_set_audio_sample(
(rewind_st->flags
(rewind_st->flags
& STATE_MGR_REWIND_ST_FLAG_FRAME_IS_REVERSED)
? audio_driver_sample_rewind
? audio_driver_sample_rewind
: audio_driver_sample);
if (current_core->retro_set_audio_sample_batch)
current_core->retro_set_audio_sample_batch(
( rewind_st->flags
( rewind_st->flags
& STATE_MGR_REWIND_ST_FLAG_FRAME_IS_REVERSED)
? audio_driver_sample_batch_rewind
? audio_driver_sample_batch_rewind
: audio_driver_sample_batch);
}

20
steam/steam.c
View File

@ -267,6 +267,7 @@ steam_core_dlc_t* steam_get_core_dlc_by_name(
void steam_install_core_dlc(steam_core_dlc_t *core_dlc)
{
size_t _len;
char msg[128] = { 0 };
bool downloading = false;
bool installed = false;
@ -284,7 +285,8 @@ void steam_install_core_dlc(steam_core_dlc_t *core_dlc)
if (downloading || installed)
{
runloop_msg_queue_push(msg_hash_to_str(MSG_CORE_STEAM_CURRENTLY_DOWNLOADING), 1, 180, true, NULL,
const char *_msg = msg_hash_to_str(MSG_CORE_STEAM_CURRENTLY_DOWNLOADING);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
return;
}
@ -297,11 +299,11 @@ void steam_install_core_dlc(steam_core_dlc_t *core_dlc)
return;
error:
snprintf(msg, sizeof(msg), "%s: (%d-%d)",
_len = snprintf(msg, sizeof(msg), "%s: (%d-%d)",
msg_hash_to_str(MSG_ERROR),
MIST_UNPACK_RESULT(result));
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Steam]: Error installing DLC %d (%d-%d)\n", core_dlc->app_id, MIST_UNPACK_RESULT(result));
@ -309,23 +311,25 @@ error:
void steam_uninstall_core_dlc(steam_core_dlc_t *core_dlc)
{
char msg[128] = { 0 };
size_t _len;
const char *_msg = NULL;
char msg[128] = { 0 };
MistResult result = mist_steam_apps_uninstall_dlc(core_dlc->app_id);
if (MIST_IS_ERROR(result))
goto error;
runloop_msg_queue_push(msg_hash_to_str(MSG_CORE_STEAM_UNINSTALLED), 1, 180, true, NULL,
_msg = msg_hash_to_str(MSG_CORE_STEAM_UNINSTALLED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return;
error:
snprintf(msg, sizeof(msg), "%s: (%d-%d)",
_len = snprintf(msg, sizeof(msg), "%s: (%d-%d)",
msg_hash_to_str(MSG_ERROR),
MIST_UNPACK_RESULT(result));
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
RARCH_ERR("[Steam]: Error uninstalling DLC %d (%d-%d)\n", core_dlc->app_id, MIST_UNPACK_RESULT(result));

7
tasks/task_autodetect_blissbox.c
View File

@ -258,7 +258,7 @@ static const blissbox_pad_type_t* input_autoconfigure_get_blissbox_pad_type_win3
/* Check for some other error */
if (!bResult)
{
if ( (ERROR_INSUFFICIENT_BUFFER == GetLastError())
if ( (ERROR_INSUFFICIENT_BUFFER == GetLastError())
&& (required_length > 0))
{
/* we got the size, now allocate buffer */
@ -354,8 +354,11 @@ found:
if (hDeviceHandle == INVALID_HANDLE_VALUE)
{
/* TODO/FIXME - localize */
const char *_msg = "Bliss-Box already in use. Please make sure other programs are not using it.";
RARCH_ERR("[Autoconf]: Can't open device for reading and writing: %d.", GetLastError());
runloop_msg_queue_push("Bliss-Box already in use. Please make sure other programs are not using it.", 2, 300, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 300, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto done;
}
}

19
tasks/task_content.c
View File

@ -1904,12 +1904,10 @@ static bool firmware_update_status(
(content_ctx->flags & CONTENT_INFO_FLAG_BIOS_IS_MISSING)
&& (content_ctx->flags & CONTENT_INFO_FLAG_CHECK_FW_BEFORE_LOADING))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_FIRMWARE),
100, 500, true, NULL,
const char *_msg = msg_hash_to_str(MSG_FIRMWARE);
runloop_msg_queue_push(_msg, strlen(_msg), 100, 500, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("[Content]: Load content blocked. Reason: %s\n",
msg_hash_to_str(MSG_FIRMWARE));
RARCH_LOG("[Content]: Load content blocked. Reason: %s\n", _msg);
return true;
}
@ -3149,8 +3147,12 @@ bool content_init(void)
case MSG_ERROR_LIBRETRO_CORE_REQUIRES_VFS:
case MSG_FAILED_TO_LOAD_CONTENT:
case MSG_ERROR_LIBRETRO_CORE_REQUIRES_CONTENT:
RARCH_ERR("[Content]: %s\n", msg_hash_to_str(error_enum));
runloop_msg_queue_push(msg_hash_to_str(error_enum), 2, ret ? 1 : 180, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
{
const char *_msg = msg_hash_to_str(error_enum);
RARCH_ERR("[Content]: %s\n", _msg);
runloop_msg_queue_push(_msg, strlen(_msg), 2, ret ? 1 : 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
break;
case MSG_UNKNOWN:
default:
@ -3168,7 +3170,8 @@ bool content_init(void)
/* Do not flush the message queue here
* > This allows any core-generated error messages
* to propagate through to the frontend */
runloop_msg_queue_push(error_string, 2, ret ? 1 : 180, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(error_string, strlen(error_string), 2, ret ? 1 : 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
free(error_string);
}

14
tasks/task_core_backup.c
View File

@ -982,13 +982,14 @@ bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
msg_hash_to_str(MSG_CORE_RESTORATION_INVALID_CONTENT),
sizeof(msg));
if (backup_filename)
strlcpy(msg + _len,
_len += strlcpy(msg + _len,
backup_filename,
sizeof(msg) - _len);
/* TODO/FIXME - localize */
RARCH_ERR("[core restore] Invalid core file selected: %s\n", backup_path);
runloop_msg_queue_push(msg, 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto error;
}
@ -1015,13 +1016,14 @@ bool task_push_core_restore(const char *backup_path, const char *dir_libretro,
? msg_hash_to_str(MSG_CORE_RESTORATION_DISABLED)
: msg_hash_to_str(MSG_CORE_INSTALLATION_DISABLED),
sizeof(msg));
strlcpy(msg + _len,
_len += strlcpy(msg + _len,
core_name,
sizeof(msg) - _len);
/* TODO/FIXME - localize */
RARCH_ERR("[core restore] Restoration disabled - core is locked: %s\n", core_path);
runloop_msg_queue_push(msg, 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto error;
}

7
tasks/task_core_updater.c
View File

@ -1079,10 +1079,9 @@ void *task_push_core_updater_download(
{
char msg[128];
size_t _len = strlcpy(msg, msg_hash_to_str(MSG_CORE_UPDATE_DISABLED), sizeof(msg));
strlcpy(msg + _len, list_entry->display_name, sizeof(msg) - _len);
runloop_msg_queue_push(msg, 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
_len += strlcpy(msg + _len, list_entry->display_name, sizeof(msg) - _len);
runloop_msg_queue_push(msg, _len, 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
goto error;

23
tasks/task_manual_content_scan.c
View File

@ -216,10 +216,9 @@ static void task_manual_content_scan_handler(retro_task_t *task)
= manual_content_scan_get_content_list(
manual_scan->task_config)))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_INVALID_CONTENT),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_INVALID_CONTENT);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,\
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto task_finished;
}
@ -232,10 +231,9 @@ static void task_manual_content_scan_handler(retro_task_t *task)
logiqx_dat_init(
manual_scan->task_config->dat_file_path)))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_LOAD_ERROR),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_LOAD_ERROR);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto task_finished;
}
}
@ -570,13 +568,12 @@ bool task_push_manual_content_scan(
calloc(1, sizeof(manual_content_scan_task_config_t))))
goto error;
if ( !manual_content_scan_get_task_config(
if (!manual_content_scan_get_task_config(
manual_scan->task_config, playlist_directory))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_INVALID_CONFIG),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_INVALID_CONFIG);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto error;
}

61
tasks/task_movie.c
View File

@ -253,29 +253,28 @@ static bool bsv_movie_start_record(input_driver_state_t * input_st, char *path)
{
size_t _len;
char msg[128];
bsv_movie_t *state = NULL;
const char *movie_rec_str = NULL;
bsv_movie_t *state = NULL;
const char *_msg = NULL;
/* this should trigger a start recording task which on failure or
success prints a message and on success sets the
input_st->bsv_movie_state_handle. */
if (!(state = bsv_movie_init_internal(path, RARCH_MOVIE_RECORD)))
{
const char *movie_rec_fail_str =
msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD);
runloop_msg_queue_push(movie_rec_fail_str,
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", movie_rec_fail_str);
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_ERR("%s.\n", _msg);
return false;
}
bsv_movie_enqueue(input_st, state, BSV_FLAG_MOVIE_RECORDING);
movie_rec_str = msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO);
_len = strlcpy(msg, movie_rec_str, sizeof(msg));
snprintf(msg + _len, sizeof(msg) - _len, " \"%s\".", path);
runloop_msg_queue_push(msg, 2, 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s \"%s\".\n", movie_rec_str, path);
_msg = msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO);
_len = strlcpy(msg, _msg, sizeof(msg));
_len += snprintf(msg + _len, sizeof(msg) - _len, " \"%s\".", path);
runloop_msg_queue_push(msg, _len, 2, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s \"%s\".\n", _msg, path);
return true;
}
@ -283,7 +282,7 @@ static bool bsv_movie_start_record(input_driver_state_t * input_st, char *path)
static bool bsv_movie_start_playback(input_driver_state_t *input_st, char *path)
{
bsv_movie_t *state = NULL;
const char *starting_movie_str = NULL;
const char *_msg = NULL;
/* This should trigger a start playback task which on failure or
success prints a message and on success sets the
input_st->bsv_movie_state_handle. */
@ -296,13 +295,11 @@ static bool bsv_movie_start_playback(input_driver_state_t *input_st, char *path)
}
bsv_movie_enqueue(input_st, state, BSV_FLAG_MOVIE_PLAYBACK);
starting_movie_str =
msg_hash_to_str(MSG_STARTING_MOVIE_PLAYBACK);
_msg = msg_hash_to_str(MSG_STARTING_MOVIE_PLAYBACK);
runloop_msg_queue_push(starting_movie_str,
2, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s.\n", starting_movie_str);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s.\n", _msg);
return true;
}
@ -375,15 +372,14 @@ static void moviectl_start_record_cb(retro_task_t *task,
/* In the future this should probably be a deferred task as well */
bool movie_stop_playback(input_driver_state_t *input_st)
{
const char *movie_playback_end_str = NULL;
const char *_msg = NULL;
/* Checks if movie is being played back. */
if (!(input_st->bsv_movie_state.flags & BSV_FLAG_MOVIE_PLAYBACK))
return false;
movie_playback_end_str = msg_hash_to_str(MSG_MOVIE_PLAYBACK_ENDED);
runloop_msg_queue_push(
movie_playback_end_str, 2, 180, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", movie_playback_end_str);
_msg = msg_hash_to_str(MSG_MOVIE_PLAYBACK_ENDED);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", _msg);
bsv_movie_deinit_full(input_st);
@ -395,13 +391,12 @@ bool movie_stop_playback(input_driver_state_t *input_st)
/* in the future this should probably be a deferred task as well */
bool movie_stop_record(input_driver_state_t *input_st)
{
const char *movie_rec_stopped_str = msg_hash_to_str(MSG_MOVIE_RECORD_STOPPED);
const char *_msg = msg_hash_to_str(MSG_MOVIE_RECORD_STOPPED);
if (!(input_st->bsv_movie_state_handle))
return false;
runloop_msg_queue_push(movie_rec_stopped_str,
2, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", movie_rec_stopped_str);
runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
RARCH_LOG("%s\n", _msg);
bsv_movie_deinit_full(input_st);
input_st->bsv_movie_state.flags &= ~(
BSV_FLAG_MOVIE_END
@ -454,7 +449,7 @@ bool movie_start_record(input_driver_state_t *input_st, char*path)
{
size_t _len;
char msg[128];
const char *movie_rec_str = msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO);
const char *_msg = msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO);
retro_task_t *task = task_init();
moviectl_task_state_t *state = (moviectl_task_state_t *)calloc(1, sizeof(*state));
@ -464,7 +459,7 @@ bool movie_start_record(input_driver_state_t *input_st, char*path)
*state = input_st->bsv_movie_state;
strlcpy(state->movie_start_path, path, sizeof(state->movie_start_path));
_len = strlcpy(msg, movie_rec_str, sizeof(msg));
_len = strlcpy(msg, _msg, sizeof(msg));
snprintf(msg + _len, sizeof(msg) - _len, " \"%s\".", path);
task->type = TASK_TYPE_NONE;

11
tasks/task_netplay_find_content.c
View File

@ -686,6 +686,7 @@ static void task_netplay_crc_scan_callback(retro_task_t *task,
if (data->current.core_loaded && (state->state & STATE_RELOAD))
{
#ifdef HAVE_DYNAMIC
const char *_msg;
command_event(CMD_EVENT_UNLOAD_CORE, NULL);
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
@ -710,14 +711,12 @@ static void task_netplay_crc_scan_callback(retro_task_t *task,
content_set_subsystem_by_name(data->current.subsystem);
}
runloop_msg_queue_push(
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED),
1, 480, true, NULL,
_msg = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_START_WHEN_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#else
runloop_msg_queue_push(
msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED),
1, 480, true, NULL,
const char *_msg = msg_hash_to_str(MSG_NETPLAY_NEED_CONTENT_LOADED);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 480, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#endif
}

4
tasks/task_overlay.c
View File

@ -271,7 +271,7 @@ static bool task_overlay_load_desc(
goto end;
}
if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
if (config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)) == 0)
{
RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
ret = false;
@ -836,7 +836,7 @@ static void task_overlay_deferred_load(retro_task_t *task)
overlay->w = overlay->h = 1.0f;
if (config_get_array(conf, overlay->config.rect.key,
overlay->config.rect.array, sizeof(overlay->config.rect.array)))
overlay->config.rect.array, sizeof(overlay->config.rect.array)) > 0)
{
char *tok, *save;
char *elem0 = NULL;

4
tasks/task_patch.c
View File

@ -751,10 +751,10 @@ static bool apply_patch_content(uint8_t **buf,
{
char msg[128];
const char *patch_filename = path_basename_nocompression(patch_path);
snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_APPLYING_PATCH),
size_t _len = snprintf(msg, sizeof(msg), msg_hash_to_str(MSG_APPLYING_PATCH),
patch_filename ? patch_filename :
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UNKNOWN));
runloop_msg_queue_push(msg, 1, 180, false, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}

7
tasks/task_pl_thumbnail_download.c
View File

@ -941,10 +941,9 @@ bool task_push_pl_entry_thumbnail_download(
}
if (next_flag == PLAYLIST_THUMBNAIL_FLAG_NONE)
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_NO_THUMBNAIL_DOWNLOAD_POSSIBLE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
const char *_msg = msg_hash_to_str(MSG_NO_THUMBNAIL_DOWNLOAD_POSSIBLE);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
goto error;
}

7
tasks/task_screenshot.c
View File

@ -190,9 +190,10 @@ static void task_screenshot_handler(retro_task_t *task)
/* Report any errors */
if (!ret)
{
char *msg = strdup(msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT));
runloop_msg_queue_push(msg, 1, (state->flags & SS_TASK_FLAG_IS_PAUSED) ? 1 : 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
free(msg);
const char *_msg = msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT);
runloop_msg_queue_push(_msg, strlen(_msg), 1,
(state->flags & SS_TASK_FLAG_IS_PAUSED) ? 1 : 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if (task->title)

4
tasks/task_steam.c
View File

@ -81,11 +81,11 @@ task_finished:
char msg[128];
size_t _len = strlcpy(msg, msg_hash_to_str(MSG_CORE_INSTALLED),
sizeof(msg));
strlcpy(msg + _len,
_len += strlcpy(msg + _len,
state->name,
sizeof(msg) - _len);
runloop_msg_queue_push(msg, 1, 180, true, NULL,
runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
}

10
tasks/task_translation.c
View File

@ -320,6 +320,7 @@ static void handle_translation_cb(
image_type = IMAGE_TYPE_PNG;
else
{
/* TODO/FIXME - localize */
RARCH_LOG("Invalid image type returned from server.\n");
goto finish;
}
@ -328,12 +329,11 @@ static void handle_translation_cb(
raw_image_file_data, (unsigned)new_image_size,
image_type))
{
/* TODO/FIXME - localize */
const char *_msg = "Video driver not supported.";
RARCH_LOG("Video driver not supported for AI Service.");
runloop_msg_queue_push(
/* msg_hash_to_str(MSG_VIDEO_DRIVER_NOT_SUPPORTED), */
"Video driver not supported.",
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else if (gfx_widgets_paused)
{

42
ui/drivers/qt/qt_dialogs.cpp
View File

@ -2029,19 +2029,17 @@ void ShaderParamsDialog::operateShaderPreset(bool save, const char *path, unsign
true);
if (ret)
runloop_msg_queue_push(
msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY),
1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO
);
{
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET),
1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_ERROR
);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
}
}
else
{
@ -2050,24 +2048,20 @@ void ShaderParamsDialog::operateShaderPreset(bool save, const char *path, unsign
path_dir_video_shader,
path_dir_menu_config))
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_SHADER_PRESET_REMOVED_SUCCESSFULLY),
1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_INFO
);
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_REMOVED_SUCCESSFULLY);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
#ifdef HAVE_MENU
menu_state_get_ptr()->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
#endif
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_ERROR_REMOVING_SHADER_PRESET),
1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT,
MESSAGE_QUEUE_CATEGORY_ERROR
);
{
const char *_msg = msg_hash_to_str(MSG_ERROR_REMOVING_SHADER_PRESET);
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
}
}
}

7
uwp/uwp_main.cpp
View File

@ -745,8 +745,11 @@ void App::OnPackageInstalling(PackageCatalog^ sender,
if (args->IsComplete)
{
char msg[512];
snprintf(msg, sizeof(msg), "Package \"%ls\" installed, a restart may be necessary", args->Package->DisplayName->Data());
runloop_msg_queue_push(msg, 1, 5 * 60, false, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
size_t _len = snprintf(msg, sizeof(msg),
"Package \"%ls\" installed, a restart may be necessary",
args->Package->DisplayName->Data());
runloop_msg_queue_push(msg, _len, 1, 5 * 60, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}