static void rmenu_set_texture(void)
{
menu_handle_t *menu = menu_driver_get_ptr();
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
if (!menu)
return;
if (menu_texture_inited)
return;
if (!menu_texture)
return;
if (!menu_texture->pixels)
return;
video_driver_set_texture_frame(menu_texture->pixels, true,
frame_buf->width, frame_buf->height, 1.0f);
menu_texture_inited = true;
}
static int menu_input_pointer(unsigned *action)
{
int pointer_device, pointer_x, pointer_y;
const struct retro_keybind *binds[MAX_USERS] = {NULL};
menu_input_t *menu_input = menu_input_get_ptr();
menu_animation_t *anim = menu_animation_get_ptr();
menu_framebuf_t *frame_buf= menu_display_fb_get_ptr();
settings_t *settings = config_get_ptr();
driver_t *driver = driver_get_ptr();
if (!settings->menu.pointer.enable)
{
memset(&menu_input->pointer, 0, sizeof(menu_input->pointer));
return 0;
}
pointer_device = driver->menu_ctx->set_texture?
RETRO_DEVICE_POINTER : RARCH_DEVICE_POINTER_SCREEN;
menu_input->pointer.pressed[0] = input_driver_state(binds, 0, pointer_device,
0, RETRO_DEVICE_ID_POINTER_PRESSED);
menu_input->pointer.pressed[1] = input_driver_state(binds, 0, pointer_device,
1, RETRO_DEVICE_ID_POINTER_PRESSED);
menu_input->pointer.back = input_driver_state(binds, 0, pointer_device,
0, RARCH_DEVICE_ID_POINTER_BACK);
pointer_x = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_X);
pointer_y = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_Y);
menu_input->pointer.x = ((pointer_x + 0x7fff) * (int)frame_buf->width) / 0xFFFF;
menu_input->pointer.y = ((pointer_y + 0x7fff) * (int)frame_buf->height) / 0xFFFF;
if (
menu_input->pointer.pressed[0] ||
menu_input->pointer.oldpressed[0] ||
menu_input->pointer.back ||
menu_input->pointer.dragging ||
(menu_input->pointer.dy != 0) ||
(menu_input->pointer.dx != 0)
)
menu_animation_set_active(anim);
return 0;
}
static void rmenu_context_reset(void)
{
char menu_bg[PATH_MAX_LENGTH] = {0};
menu_handle_t *menu = menu_driver_get_ptr();
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return;
if (*global->menu.wallpaper)
strlcpy(menu_bg, global->menu.wallpaper, sizeof(menu_bg));
else
rmenu_wallpaper_set_defaults(menu_bg, sizeof(menu_bg));
if (path_file_exists(menu_bg))
texture_image_load(menu_texture, menu_bg);
frame_buf->width = menu_texture->width;
frame_buf->height = menu_texture->height;
menu_texture_inited = false;
}
static void glui_render(void)
{
int bottom;
unsigned width, height;
glui_handle_t *glui = NULL;
menu_display_t *disp = menu_display_get_ptr();
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
menu_handle_t *menu = menu_driver_get_ptr();
menu_input_t *menu_input = menu_input_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu || !menu->userdata)
return;
video_driver_get_size(&width, &height);
glui = (glui_handle_t*)menu->userdata;
menu_animation_update(disp->animation,
disp->animation->delta_time / IDEAL_DT);
/* TODO/FIXME - we don't use framebuffer at all
* for GLUI, we should refactor this dependency
* away. */
frame_buf->width = width;
frame_buf->height = height;
if (settings->menu.pointer.enable)
{
menu_input->pointer.ptr =
(menu_input->pointer.y - glui->line_height + menu->scroll_y - 16)
/ glui->line_height;
if (menu_input->pointer.dragging)
menu->scroll_y -= menu_input->pointer.dy;
}
if (settings->menu.mouse.enable)
{
if (menu_input->mouse.scrolldown)
menu->scroll_y += 10;
if (menu_input->mouse.scrollup)
menu->scroll_y -= 10;
menu_input->mouse.ptr =
(menu_input->mouse.y - glui->line_height + menu->scroll_y - 16)
/ glui->line_height;
}
if (menu_entries_get_end() < height / glui->line_height)
menu_entries_set_start(0);
if (menu->scroll_y < 0)
menu->scroll_y = 0;
bottom = menu_entries_get_end() * glui->line_height
- height + disp->header_height * 2;
if (menu->scroll_y > bottom)
menu->scroll_y = bottom;
if (menu_entries_get_end() * glui->line_height
< height - disp->header_height*2)
menu->scroll_y = 0;
}
static int menu_input_mouse(unsigned *action)
{
video_viewport_t vp;
const struct retro_keybind *binds[MAX_USERS];
menu_animation_t *anim = menu_animation_get_ptr();
menu_input_t *menu_input = menu_input_get_ptr();
menu_framebuf_t *frame_buf= menu_display_fb_get_ptr();
settings_t *settings = config_get_ptr();
if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && input_overlay_is_alive())
#endif
)
{
memset(&menu_input->mouse, 0, sizeof(menu_input->mouse));
return 0;
}
if (!video_driver_viewport_info(&vp))
return -1;
if (menu_input->mouse.hwheeldown)
{
*action = MENU_ACTION_LEFT;
menu_input->mouse.hwheeldown = false;
return 0;
}
if (menu_input->mouse.hwheelup)
{
*action = MENU_ACTION_RIGHT;
menu_input->mouse.hwheelup = false;
return 0;
}
menu_input->mouse.left = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_LEFT);
menu_input->mouse.right = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_RIGHT);
menu_input->mouse.wheelup = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_WHEELUP);
menu_input->mouse.wheeldown = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_WHEELDOWN);
menu_input->mouse.hwheelup = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELUP);
menu_input->mouse.hwheeldown = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELDOWN);
menu_input->mouse.dx = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_X);
menu_input->mouse.dy = input_driver_state(binds, 0, RETRO_DEVICE_MOUSE,
0, RETRO_DEVICE_ID_MOUSE_Y);
menu_input->mouse.screen_x += menu_input->mouse.dx;
menu_input->mouse.screen_y += menu_input->mouse.dy;
menu_input->mouse.x = ((int)menu_input->mouse.screen_x * (int)frame_buf->width) / (int)vp.width;
menu_input->mouse.y = ((int)menu_input->mouse.screen_y * (int)frame_buf->height) / (int)vp.height;
if (menu_input->mouse.x < 5)
menu_input->mouse.x = 5;
if (menu_input->mouse.y < 5)
menu_input->mouse.y = 5;
if (menu_input->mouse.x > (int)frame_buf->width - 5)
menu_input->mouse.x = frame_buf->width - 5;
if (menu_input->mouse.y > (int)frame_buf->height - 5)
menu_input->mouse.y = frame_buf->height - 5;
menu_input->mouse.scrollup = (menu_input->mouse.y == 5);
menu_input->mouse.scrolldown = (menu_input->mouse.y == (int)frame_buf->height - 5);
if (
(menu_input->mouse.dx != 0) ||
(menu_input->mouse.dy !=0) ||
menu_input->mouse.left ||
menu_input->mouse.wheelup ||
menu_input->mouse.wheeldown ||
menu_input->mouse.hwheelup ||
menu_input->mouse.hwheeldown ||
menu_input->mouse.scrollup ||
menu_input->mouse.scrolldown
)
menu_animation_set_active(anim);
return 0;
}
static void rmenu_xui_render(void)
{
size_t end, i;
char title[PATH_MAX_LENGTH] = {0};
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
menu_animation_t *anim = menu_animation_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
menu_navigation_t *nav = menu_navigation_get_ptr();
uint64_t frame_count = video_driver_get_frame_count();
if (!menu)
return;
if (
menu_entries_needs_refresh() &&
menu_driver_alive() &&
!disp->msg_force
)
return;
menu_display_fb_unset_dirty();
anim->is_active = false;
anim->label.is_updated = false;
rmenu_xui_render_background();
if (XuiHandleIsValid(m_menutitle))
{
menu_entries_get_title(title, sizeof(title));
mbstowcs(strw_buffer, title, sizeof(strw_buffer) / sizeof(wchar_t));
XuiTextElementSetText(m_menutitle, strw_buffer);
menu_animation_ticker_line(title, RXUI_TERM_WIDTH - 3, (unsigned int)frame_count / 15, title, true);
}
if (XuiHandleIsValid(m_menutitle))
{
menu_entries_get_core_title(title, sizeof(title));
mbstowcs(strw_buffer, title, sizeof(strw_buffer) / sizeof(wchar_t));
XuiTextElementSetText(m_menutitlebottom, strw_buffer);
}
end = menu_entries_get_end();
for (i = 0; i < end; i++)
{
char entry_path[PATH_MAX_LENGTH] = {0};
char entry_value[PATH_MAX_LENGTH] = {0};
char msg_right[PATH_MAX_LENGTH] = {0};
wchar_t msg_left[PATH_MAX_LENGTH] = {0};
menu_entry_get_value(i, entry_value, sizeof(entry_value));
menu_entry_get_path(i, entry_path, sizeof(entry_path));
mbstowcs(msg_left, entry_path, sizeof(msg_left) / sizeof(wchar_t));
mbstowcs(msg_right, entry_value, sizeof(msg_right) / sizeof(wchar_t));
rmenu_xui_set_list_text(i, msg_left, msg_right);
}
XuiListSetCurSelVisible(m_menulist, nav->selection_ptr);
if (menu->keyboard.display)
{
char msg[1024] = {0};
const char *str = *menu->keyboard.buffer;
if (!str)
str = "";
snprintf(msg, sizeof(msg), "%s\n%s", menu->keyboard.label, str);
rmenu_xui_render_messagebox(msg);
}
}
bool menu_display_ctl(enum menu_display_ctl_state state, void *data)
{
unsigned width, height;
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
settings_t *settings = config_get_ptr();
switch (state)
{
case MENU_DISPLAY_CTL_FONT_BUF:
{
void **ptr = (void**)data;
if (!ptr)
return false;
*ptr = disp->font.buf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_BUF:
{
void **ptr = (void**)data;
if (!ptr)
return false;
disp->font.buf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_FB:
{
uint8_t **ptr = (uint8_t**)data;
if (!ptr)
return false;
*ptr = (uint8_t*)disp->font.framebuf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_FB:
{
uint8_t **ptr = (uint8_t**)data;
if (!ptr)
return false;
disp->font.framebuf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_LIBRETRO_RUNNING:
{
global_t *global = global_get_ptr();
if (!settings->menu.pause_libretro)
if (global->inited.main && (global->inited.core.type != CORE_TYPE_DUMMY))
return true;
}
break;
case MENU_DISPLAY_CTL_LIBRETRO:
video_driver_set_texture_enable(true, false);
if (menu_display_ctl(MENU_DISPLAY_CTL_LIBRETRO_RUNNING, NULL))
{
driver_t *driver = driver_get_ptr();
bool block_libretro_input = driver->block_libretro_input;
driver->block_libretro_input = true;
core.retro_run();
driver->block_libretro_input = block_libretro_input;
return true;
}
video_driver_cached_frame();
return true;
case MENU_DISPLAY_CTL_SET_WIDTH:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
frame_buf->width = *ptr;
}
return true;
case MENU_DISPLAY_CTL_WIDTH:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = frame_buf->width;
}
return true;
case MENU_DISPLAY_CTL_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = frame_buf->height;
}
return true;
case MENU_DISPLAY_CTL_HEADER_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = disp->header_height;
}
return true;
case MENU_DISPLAY_CTL_SET_HEADER_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
disp->header_height = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_SIZE:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = disp->font.size;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_SIZE:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
disp->font.size = *ptr;
}
return true;
case MENU_DISPLAY_CTL_SET_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
frame_buf->height = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FB_DATA:
{
uint16_t **ptr = (uint16_t**)data;
if (!ptr)
return false;
*ptr = frame_buf->data;
}
return true;
case MENU_DISPLAY_CTL_SET_FB_DATA:
{
uint16_t *ptr = (uint16_t*)data;
if (!ptr)
return false;
frame_buf->data = ptr;
}
return true;
case MENU_DISPLAY_CTL_FB_PITCH:
{
size_t *ptr = (size_t*)data;
if (!ptr)
return false;
*ptr = frame_buf->pitch;
}
return true;
case MENU_DISPLAY_CTL_SET_FB_PITCH:
{
size_t *ptr = (size_t*)data;
if (!ptr)
return false;
frame_buf->pitch = *ptr;
}
return true;
case MENU_DISPLAY_CTL_MSG_FORCE:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
*ptr = disp->msg_force;
}
return true;
case MENU_DISPLAY_CTL_SET_MSG_FORCE:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
disp->msg_force = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_DATA_INIT:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
*ptr = disp->font.alloc_framebuf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_DATA_INIT:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
disp->font.alloc_framebuf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_UPDATE_PENDING:
{
bool ptr;
menu_display_ctl(MENU_DISPLAY_CTL_GET_FRAMEBUFFER_DIRTY_FLAG, &ptr);
if (menu_animation_ctl(MENU_ANIMATION_CTL_IS_ACTIVE, NULL) || ptr)
return true;
}
return false;
case MENU_DISPLAY_CTL_SET_VIEWPORT:
video_driver_get_size(&width, &height);
video_driver_set_viewport(width,
height, true, false);
return true;
case MENU_DISPLAY_CTL_UNSET_VIEWPORT:
video_driver_get_size(&width, &height);
video_driver_set_viewport(width,
height, false, true);
return true;
case MENU_DISPLAY_CTL_GET_FRAMEBUFFER_DIRTY_FLAG:
{
bool *ptr = (bool*)data;
if (!ptr || !frame_buf)
return false;
*ptr = frame_buf->dirty;
}
return true;
case MENU_DISPLAY_CTL_SET_FRAMEBUFFER_DIRTY_FLAG:
if (frame_buf && frame_buf->data)
frame_buf->dirty = true;
return true;
case MENU_DISPLAY_CTL_UNSET_FRAMEBUFFER_DIRTY_FLAG:
if (frame_buf && frame_buf->data)
frame_buf->dirty = false;
return true;
case MENU_DISPLAY_CTL_GET_DPI:
{
float *dpi = (float*)data;
*dpi = menu_dpi_override_value;
if (!settings)
return true;
if (settings->menu.dpi.override_enable)
*dpi = settings->menu.dpi.override_value;
else if (!gfx_ctx_get_metrics(DISPLAY_METRIC_DPI, dpi))
*dpi = menu_dpi_override_value;
}
return true;
}
return false;
}
