Emulation/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2025-04-02 10:51:52 -04:00
Code Issues Projects Releases Packages Wiki Activity

Decouple 'overlay' state from driver_t

Browse source
This commit is contained in:
twinaphex 2015-07-09 01:10:30 +02:00
parent 387d687ef9
commit cdf3ce309e
9 changed files with 163 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
command_event.c
View file

@ -1261,41 +1261,19 @@ bool event_command(enum event_command cmd)
break; break;
case EVENT_CMD_OVERLAY_DEINIT: case EVENT_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (driver->overlay) input_overlay_free_ptr();
input_overlay_free(driver->overlay);
driver->overlay = NULL;
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state));
#endif #endif
break; break;
case EVENT_CMD_OVERLAY_INIT: case EVENT_CMD_OVERLAY_INIT:
event_command(EVENT_CMD_OVERLAY_DEINIT); event_command(EVENT_CMD_OVERLAY_DEINIT);
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (driver->osk_enable) if (input_overlay_new_ptr() == -1)
{
if (!*settings->osk.overlay)
break;
}
else
{
if (!*settings->input.overlay)
break;
}
driver->overlay = input_overlay_new(
driver->osk_enable ?
settings->osk.overlay : settings->input.overlay,
driver->osk_enable ?
settings->osk.enable : settings->input.overlay_enable,
settings->input.overlay_opacity,
settings->input.overlay_scale);
if (!driver->overlay)
RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD_OVERLAY)); RARCH_ERR("%s.\n", msg_hash_to_str(MSG_FAILED_TO_LOAD_OVERLAY));
#endif #endif
break; break;
case EVENT_CMD_OVERLAY_NEXT: case EVENT_CMD_OVERLAY_NEXT:
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
input_overlay_next(driver->overlay, settings->input.overlay_opacity); input_overlay_next(input_overlay_get_ptr(), settings->input.overlay_opacity);
#endif #endif
break; break;
case EVENT_CMD_DSP_FILTER_DEINIT: case EVENT_CMD_DSP_FILTER_DEINIT:
@ -1395,13 +1373,13 @@ bool event_command(enum event_command cmd)
break; break;
case EVENT_CMD_OVERLAY_SET_SCALE_FACTOR: case EVENT_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
input_overlay_set_scale_factor(driver->overlay, input_overlay_set_scale_factor(input_overlay_get_ptr(),
settings->input.overlay_scale); settings->input.overlay_scale);
#endif #endif
break; break;
case EVENT_CMD_OVERLAY_SET_ALPHA_MOD: case EVENT_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
input_overlay_set_alpha_mod(driver->overlay, input_overlay_set_alpha_mod(input_overlay_get_ptr(),
settings->input.overlay_opacity); settings->input.overlay_opacity);
#endif #endif
break; break;

5
driver.h
View file

@ -287,11 +287,6 @@ typedef struct driver
* TODO: Refactor this better. */ * TODO: Refactor this better. */
bool gfx_use_rgba; bool gfx_use_rgba;
#ifdef HAVE_OVERLAY
input_overlay_t *overlay;
input_overlay_state_t overlay_state;
#endif
/* Interface for "poking". */ /* Interface for "poking". */
const video_poke_interface_t *video_poke; const video_poke_interface_t *video_poke;

10
input/input_driver.c
View file

@ -213,9 +213,10 @@ bool input_driver_key_pressed(int key)
retro_input_t input_driver_keys_pressed(void) retro_input_t input_driver_keys_pressed(void)
{ {
int key; int key;
retro_input_t ret = 0; retro_input_t ret = 0;
driver_t *driver = driver_get_ptr(); driver_t *driver = driver_get_ptr();
const input_driver_t *input = input_get_ptr(driver); const input_driver_t *input = input_get_ptr(driver);
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
for (key = 0; key < RARCH_BIND_LIST_END; key++) for (key = 0; key < RARCH_BIND_LIST_END; key++)
{ {
@ -225,7 +226,8 @@ retro_input_t input_driver_keys_pressed(void)
state = input->key_pressed(driver->input_data, key); state = input->key_pressed(driver->input_data, key);
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
state = state || (driver->overlay_state.buttons & (1ULL << key)); if (ol_state)
state = state || (ol_state->buttons & (1ULL << key));
#endif #endif
#ifdef HAVE_COMMAND #ifdef HAVE_COMMAND

76
input/input_overlay.c
View file

@ -26,6 +26,7 @@
#include <rhash.h> #include <rhash.h>
#include "input_overlay.h" #include "input_overlay.h"
#include "../configuration.h"
#include "../driver.h" #include "../driver.h"
#include "input_common.h" #include "input_common.h"
@ -35,6 +36,33 @@
#define KEY_ANALOG_LEFT 0x56b92e81U #define KEY_ANALOG_LEFT 0x56b92e81U
#define KEY_ANALOG_RIGHT 0x2e4dc654U #define KEY_ANALOG_RIGHT 0x2e4dc654U
static input_overlay_t *overlay_ptr;
static input_overlay_state_t *overlay_state_ptr;
input_overlay_t *input_overlay_get_ptr(void)
{
return overlay_ptr;
}
input_overlay_state_t *input_overlay_get_state_ptr(void)
{
return overlay_state_ptr;
}
bool input_overlay_is_active(void)
{
input_overlay_t *overlay = input_overlay_get_ptr();
if (!overlay)
return false;
if (overlay->state == OVERLAY_STATUS_ALIVE)
return false;
if (overlay->state == OVERLAY_STATUS_NONE)
return false;
return true;
}
/** /**
* input_overlay_scale: * input_overlay_scale:
* @ol : Overlay handle. * @ol : Overlay handle.
@ -1156,6 +1184,54 @@ void input_overlay_free(input_overlay_t *ol)
free(ol); free(ol);
} }
void input_overlay_free_ptr(void)
{
input_overlay_free(overlay_ptr);
overlay_ptr = NULL;
if (overlay_state_ptr)
free(overlay_state_ptr);
overlay_state_ptr = NULL;
}
int input_overlay_new_ptr(void)
{
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (driver->osk_enable)
{
if (!*settings->osk.overlay)
return 1;
}
else
{
if (!*settings->input.overlay)
return 1;
}
overlay_state_ptr = (input_overlay_state_t *)calloc(1, sizeof(*overlay_state_ptr));
if (!overlay_state_ptr)
return -1;
overlay_ptr = input_overlay_new(
driver->osk_enable ?
settings->osk.overlay : settings->input.overlay,
driver->osk_enable ?
settings->osk.enable : settings->input.overlay_enable,
settings->input.overlay_opacity,
settings->input.overlay_scale);
if (!overlay_ptr)
{
free(overlay_state_ptr);
return -1;
}
return 0;
}
/** /**
* input_overlay_set_alpha_mod: * input_overlay_set_alpha_mod:
* @ol : Overlay handle. * @ol : Overlay handle.

10
input/input_overlay.h
View file

@ -338,6 +338,16 @@ void input_overlay_set_scale_factor(input_overlay_t *ol, float scale);
**/ **/
void input_overlay_next(input_overlay_t *ol, float opacity); void input_overlay_next(input_overlay_t *ol, float opacity);
input_overlay_t *input_overlay_get_ptr(void);
input_overlay_state_t *input_overlay_get_state_ptr(void);
bool input_overlay_is_active(void);
void input_overlay_free_ptr(void);
int input_overlay_new_ptr(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

91
libretro_version_1.c
View file

@ -157,10 +157,11 @@ static int16_t input_state(unsigned port, unsigned device,
{ {
size_t i; size_t i;
const struct retro_keybind *libretro_input_binds[MAX_USERS]; const struct retro_keybind *libretro_input_binds[MAX_USERS];
int16_t res = 0; int16_t res = 0;
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
driver_t *driver = driver_get_ptr(); driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
for (i = 0; i < MAX_USERS; i++) for (i = 0; i < MAX_USERS; i++)
libretro_input_binds[i] = settings->input.binds[i]; libretro_input_binds[i] = settings->input.binds[i];
@ -190,13 +191,13 @@ static int16_t input_state(unsigned port, unsigned device,
switch (device) switch (device)
{ {
case RETRO_DEVICE_JOYPAD: case RETRO_DEVICE_JOYPAD:
if (driver->overlay_state.buttons & (UINT64_C(1) << id)) if (ol_state->buttons & (UINT64_C(1) << id))
res |= 1; res |= 1;
break; break;
case RETRO_DEVICE_KEYBOARD: case RETRO_DEVICE_KEYBOARD:
if (id < RETROK_LAST) if (id < RETROK_LAST)
{ {
if (OVERLAY_GET_KEY(&driver->overlay_state, id)) if (OVERLAY_GET_KEY(ol_state, id))
res |= 1; res |= 1;
} }
break; break;
@ -208,8 +209,8 @@ static int16_t input_state(unsigned port, unsigned device,
base = 2; base = 2;
if (id == RETRO_DEVICE_ID_ANALOG_Y) if (id == RETRO_DEVICE_ID_ANALOG_Y)
base += 1; base += 1;
if (driver->overlay_state.analog[base]) if (ol_state->analog[base])
res = driver->overlay_state.analog[base]; res = ol_state->analog[base];
} }
break; break;
} }
@ -245,17 +246,18 @@ static INLINE void input_poll_overlay(
{ {
input_overlay_state_t old_key_state; input_overlay_state_t old_key_state;
unsigned i, j, device; unsigned i, j, device;
uint16_t key_mod = 0; uint16_t key_mod = 0;
bool polled = false; bool polled = false;
driver_t *driver = driver_get_ptr(); driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
input_overlay_state_t *ol_state = input_overlay_get_state_ptr();
if (overlay_device->state != OVERLAY_STATUS_ALIVE) if (overlay_device->state != OVERLAY_STATUS_ALIVE || !ol_state)
return; return;
memcpy(old_key_state.keys, driver->overlay_state.keys, memcpy(old_key_state.keys, ol_state->keys,
sizeof(driver->overlay_state.keys)); sizeof(ol_state->keys));
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state)); memset(ol_state, 0, sizeof(*ol_state));
device = input_overlay_full_screen(overlay_device) ? device = input_overlay_full_screen(overlay_device) ?
RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER; RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER;
@ -273,43 +275,43 @@ static INLINE void input_poll_overlay(
input_overlay_poll(overlay_device, &polled_data, x, y); input_overlay_poll(overlay_device, &polled_data, x, y);
driver->overlay_state.buttons |= polled_data.buttons; ol_state->buttons |= polled_data.buttons;
for (j = 0; j < ARRAY_SIZE(driver->overlay_state.keys); j++) for (j = 0; j < ARRAY_SIZE(ol_state->keys); j++)
driver->overlay_state.keys[j] |= polled_data.keys[j]; ol_state->keys[j] |= polled_data.keys[j];
/* Fingers pressed later take prio and matched up /* Fingers pressed later take prio and matched up
* with overlay poll priorities. */ * with overlay poll priorities. */
for (j = 0; j < 4; j++) for (j = 0; j < 4; j++)
if (polled_data.analog[j]) if (polled_data.analog[j])
driver->overlay_state.analog[j] = polled_data.analog[j]; ol_state->analog[j] = polled_data.analog[j];
polled = true; polled = true;
} }
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LSHIFT) || if (OVERLAY_GET_KEY(ol_state, RETROK_LSHIFT) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RSHIFT)) OVERLAY_GET_KEY(ol_state, RETROK_RSHIFT))
key_mod |= RETROKMOD_SHIFT; key_mod |= RETROKMOD_SHIFT;
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LCTRL) || if (OVERLAY_GET_KEY(ol_state, RETROK_LCTRL) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RCTRL)) OVERLAY_GET_KEY(ol_state, RETROK_RCTRL))
key_mod |= RETROKMOD_CTRL; key_mod |= RETROKMOD_CTRL;
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LALT) || if (OVERLAY_GET_KEY(ol_state, RETROK_LALT) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RALT)) OVERLAY_GET_KEY(ol_state, RETROK_RALT))
key_mod |= RETROKMOD_ALT; key_mod |= RETROKMOD_ALT;
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LMETA) || if (OVERLAY_GET_KEY(ol_state, RETROK_LMETA) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RMETA)) OVERLAY_GET_KEY(ol_state, RETROK_RMETA))
key_mod |= RETROKMOD_META; key_mod |= RETROKMOD_META;
/* CAPSLOCK SCROLLOCK NUMLOCK */ /* CAPSLOCK SCROLLOCK NUMLOCK */
for (i = 0; i < ARRAY_SIZE(driver->overlay_state.keys); i++) for (i = 0; i < ARRAY_SIZE(ol_state->keys); i++)
{ {
if (driver->overlay_state.keys[i] != old_key_state.keys[i]) if (ol_state->keys[i] != old_key_state.keys[i])
{ {
uint32_t orig_bits = old_key_state.keys[i]; uint32_t orig_bits = old_key_state.keys[i];
uint32_t new_bits = driver->overlay_state.keys[i]; uint32_t new_bits = ol_state->keys[i];
for (j = 0; j < 32; j++) for (j = 0; j < 32; j++)
if ((orig_bits & (1 << j)) != (new_bits & (1 << j))) if ((orig_bits & (1 << j)) != (new_bits & (1 << j)))
@ -324,13 +326,13 @@ static INLINE void input_poll_overlay(
unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j; unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j;
unsigned bind_minus = bind_plus + 1; unsigned bind_minus = bind_plus + 1;
if (driver->overlay_state.analog[j]) if (ol_state->analog[j])
continue; continue;
if (driver->overlay_state.buttons & (1UL << bind_plus)) if (ol_state->buttons & (1UL << bind_plus))
driver->overlay_state.analog[j] += 0x7fff; ol_state->analog[j] += 0x7fff;
if (driver->overlay_state.buttons & (1UL << bind_minus)) if (ol_state->buttons & (1UL << bind_minus))
driver->overlay_state.analog[j] -= 0x7fff; ol_state->analog[j] -= 0x7fff;
} }
/* Check for analog_dpad_mode. /* Check for analog_dpad_mode.
@ -346,17 +348,17 @@ static INLINE void input_poll_overlay(
if (settings->input.analog_dpad_mode[0] == ANALOG_DPAD_LSTICK) if (settings->input.analog_dpad_mode[0] == ANALOG_DPAD_LSTICK)
analog_base = 0; analog_base = 0;
analog_x = (float)driver->overlay_state.analog[analog_base + 0] / 0x7fff; analog_x = (float)ol_state->analog[analog_base + 0] / 0x7fff;
analog_y = (float)driver->overlay_state.analog[analog_base + 1] / 0x7fff; analog_y = (float)ol_state->analog[analog_base + 1] / 0x7fff;
if (analog_x <= -settings->input.axis_threshold) if (analog_x <= -settings->input.axis_threshold)
driver->overlay_state.buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_LEFT); ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_LEFT);
if (analog_x >= settings->input.axis_threshold) if (analog_x >= settings->input.axis_threshold)
driver->overlay_state.buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_RIGHT); ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_RIGHT);
if (analog_y <= -settings->input.axis_threshold) if (analog_y <= -settings->input.axis_threshold)
driver->overlay_state.buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_UP); ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_UP);
if (analog_y >= settings->input.axis_threshold) if (analog_y >= settings->input.axis_threshold)
driver->overlay_state.buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_DOWN); ol_state->buttons |= (1UL << RETRO_DEVICE_ID_JOYPAD_DOWN);
break; break;
} }
@ -380,12 +382,13 @@ static void input_poll(void)
{ {
driver_t *driver = driver_get_ptr(); driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
input_overlay_t *overlay = input_overlay_get_ptr();
input_driver_poll(); input_driver_poll();
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (driver->overlay) if (overlay)
input_poll_overlay(driver->overlay, input_poll_overlay(overlay,
settings->input.overlay_opacity); settings->input.overlay_opacity);
#endif #endif

9
menu/menu_input.c
View file

@ -595,10 +595,11 @@ static int menu_input_mouse(unsigned *action)
menu_input_t *menu_input = menu_input_get_ptr(); menu_input_t *menu_input = menu_input_get_ptr();
menu_framebuf_t *frame_buf= menu_display_fb_get_ptr(); menu_framebuf_t *frame_buf= menu_display_fb_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
input_overlay_t *overlay = input_overlay_get_ptr();
if (!settings->menu.mouse.enable if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay) || (settings->input.overlay_enable && driver && overlay)
#endif #endif
) )
{ {
@ -760,12 +761,13 @@ static int menu_input_mouse_post_iterate(uint64_t *input_mouse,
menu_input_t *menu_input = menu_input_get_ptr(); menu_input_t *menu_input = menu_input_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr(); menu_list_t *menu_list = menu_list_get_ptr();
menu_navigation_t *nav = menu_navigation_get_ptr(); menu_navigation_t *nav = menu_navigation_get_ptr();
input_overlay_t *overlay = input_overlay_get_ptr();
*input_mouse = MOUSE_ACTION_NONE; *input_mouse = MOUSE_ACTION_NONE;
if (!settings->menu.mouse.enable if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay) || (settings->input.overlay_enable && driver && overlay)
#endif #endif
) )
{ {
@ -874,13 +876,14 @@ static int menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
menu_input_t *menu_input = menu_input_get_ptr(); menu_input_t *menu_input = menu_input_get_ptr();
driver_t *driver = driver_get_ptr(); driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
input_overlay_t *overlay = input_overlay_get_ptr();
if (!menu_input) if (!menu_input)
return -1; return -1;
if (!settings->menu.pointer.enable if (!settings->menu.pointer.enable
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay) || (settings->input.overlay_enable && driver && overlay)
#endif #endif
) )
return 0; return 0;

5
runloop_data.c
View file

@ -147,16 +147,13 @@ static void data_runloop_iterate(bool is_thread)
bool rarch_main_data_active(void) bool rarch_main_data_active(void)
{ {
bool active = false; bool active = false;
driver_t *driver = driver_get_ptr();
#ifdef HAVE_LIBRETRODB #ifdef HAVE_LIBRETRODB
if (rarch_main_data_db_is_active()) if (rarch_main_data_db_is_active())
active = true; active = true;
#endif #endif
#ifdef HAVE_OVERLAY #ifdef HAVE_OVERLAY
if (driver && driver->overlay && if (input_overlay_is_active())
(driver->overlay->state != OVERLAY_STATUS_ALIVE
&& driver->overlay->state != OVERLAY_STATUS_NONE))
active = true; active = true;
#endif #endif
if (rarch_main_data_nbio_image_get_handle()) if (rarch_main_data_nbio_image_get_handle())

27
tasks/task_overlay.c
View file

@ -18,7 +18,7 @@
#include <rthreads/rthreads.h> #include <rthreads/rthreads.h>
#endif #endif
#include "../driver.h" #include "../input/input_overlay.h"
#include "../runloop.h" #include "../runloop.h"
#include "tasks.h" #include "tasks.h"
@ -28,11 +28,10 @@ static slock_t *overlay_lock;
void rarch_main_data_overlay_image_upload_iterate(bool is_thread) void rarch_main_data_overlay_image_upload_iterate(bool is_thread)
{ {
driver_t *driver = driver_get_ptr(); input_overlay_t *overlay = input_overlay_get_ptr();
if (rarch_main_is_idle()) if (rarch_main_is_idle())
return; return;
if (!driver->overlay) if (!overlay)
return; return;
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
@ -40,10 +39,10 @@ void rarch_main_data_overlay_image_upload_iterate(bool is_thread)
slock_lock(overlay_lock); slock_lock(overlay_lock);
#endif #endif
switch (driver->overlay->state) switch (overlay->state)
{ {
case OVERLAY_STATUS_DEFERRED_LOADING: case OVERLAY_STATUS_DEFERRED_LOADING:
input_overlay_load_overlays_iterate(driver->overlay); input_overlay_load_overlays_iterate(overlay);
break; break;
default: default:
break; break;
@ -57,7 +56,7 @@ void rarch_main_data_overlay_image_upload_iterate(bool is_thread)
void rarch_main_data_overlay_iterate(bool is_thread) void rarch_main_data_overlay_iterate(bool is_thread)
{ {
driver_t *driver = NULL; input_overlay_t *overlay = input_overlay_get_ptr();
if (rarch_main_is_idle()) if (rarch_main_is_idle())
return; return;
@ -67,27 +66,25 @@ void rarch_main_data_overlay_iterate(bool is_thread)
slock_lock(overlay_lock); slock_lock(overlay_lock);
#endif #endif
driver = driver_get_ptr(); if (!overlay)
if (!driver || !driver->overlay)
goto end; goto end;
switch (driver->overlay->state) switch (overlay->state)
{ {
case OVERLAY_STATUS_DEFERRED_LOAD: case OVERLAY_STATUS_DEFERRED_LOAD:
input_overlay_load_overlays(driver->overlay); input_overlay_load_overlays(overlay);
break; break;
case OVERLAY_STATUS_NONE: case OVERLAY_STATUS_NONE:
case OVERLAY_STATUS_ALIVE: case OVERLAY_STATUS_ALIVE:
break; break;
case OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE: case OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE:
input_overlay_load_overlays_resolve_iterate(driver->overlay); input_overlay_load_overlays_resolve_iterate(overlay);
break; break;
case OVERLAY_STATUS_DEFERRED_DONE: case OVERLAY_STATUS_DEFERRED_DONE:
input_overlay_new_done(driver->overlay); input_overlay_new_done(overlay);
break; break;
case OVERLAY_STATUS_DEFERRED_ERROR: case OVERLAY_STATUS_DEFERRED_ERROR:
input_overlay_free(driver->overlay); input_overlay_free(overlay);
break; break;
default: default:
break; break;