void handle_state(monitor_t *m, desktop_t *d, node_t *n, xcb_atom_t state, unsigned int action)
{
if (state == ewmh->_NET_WM_STATE_FULLSCREEN) {
if (action == XCB_EWMH_WM_STATE_ADD)
set_fullscreen(n, true);
else if (action == XCB_EWMH_WM_STATE_REMOVE)
set_fullscreen(n, false);
else if (action == XCB_EWMH_WM_STATE_TOGGLE)
set_fullscreen(n, !n->client->fullscreen);
arrange(m, d);
} else if (state == ewmh->_NET_WM_STATE_STICKY) {
if (action == XCB_EWMH_WM_STATE_ADD)
set_sticky(m, d, n, true);
else if (action == XCB_EWMH_WM_STATE_REMOVE)
set_sticky(m, d, n, false);
else if (action == XCB_EWMH_WM_STATE_TOGGLE)
set_sticky(m, d, n, !n->client->sticky);
} else if (state == ewmh->_NET_WM_STATE_DEMANDS_ATTENTION) {
if (action == XCB_EWMH_WM_STATE_ADD)
set_urgency(m, d, n, true);
else if (action == XCB_EWMH_WM_STATE_REMOVE)
set_urgency(m, d, n, false);
else if (action == XCB_EWMH_WM_STATE_TOGGLE)
set_urgency(m, d, n, !n->client->urgent);
}
}
static void
create_surface(struct window *window)
{
struct display *display = window->display;
EGLBoolean ret;
window->surface = wl_compositor_create_surface(display->compositor);
window->shell_surface = wl_shell_get_shell_surface(display->shell,
window->surface);
wl_shell_surface_add_listener(window->shell_surface,
&shell_surface_listener, window);
window->native =
wl_egl_window_create(window->surface,
window->window_size.width,
window->window_size.height);
window->egl_surface =
eglCreateWindowSurface(display->egl.dpy,
display->egl.conf,
window->native, NULL);
wl_shell_surface_set_title(window->shell_surface, "simple-egl");
ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
window->egl_surface, window->display->egl.ctx);
assert(ret == EGL_TRUE);
if (!window->frame_sync)
eglSwapInterval(display->egl.dpy, 0);
set_fullscreen(window, window->fullscreen);
}
static int init(void) {
LOG_DEBUG(2,"Initialising SDL video driver\n");
#ifdef WINDOWS32
if (!getenv("SDL_VIDEODRIVER"))
putenv("SDL_VIDEODRIVER=windib");
#endif
if (!SDL_WasInit(SDL_INIT_NOPARACHUTE)) {
if (SDL_Init(SDL_INIT_NOPARACHUTE) < 0) {
LOG_ERROR("Failed to initialise SDL: %s\n", SDL_GetError());
return 1;
}
}
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
LOG_ERROR("Failed to initialise SDL video driver: %s\n", SDL_GetError());
return 1;
}
if (set_fullscreen(xroar_fullscreen))
return 1;
#ifdef WINDOWS32
{
SDL_version sdlver;
SDL_SysWMinfo sdlinfo;
SDL_VERSION(&sdlver);
sdlinfo.version = sdlver;
SDL_GetWMInfo(&sdlinfo);
windows32_main_hwnd = sdlinfo.window;
}
#endif
set_mode(0);
return 0;
}
void set_fullscreen(bool ison)
{
_set_fullscreen(ison);
if(disp != NULL) {
set_fullscreen(disp->video(), ison);
}
}
void
key_handler_togglefs(struct key *key)
{
struct monitor *mon = selmon;
(void)key;
if (mon->sel)
set_fullscreen(mon->sel, !mon->sel->fullscreen);
}
void renderspuSetVBoxConfiguration( RenderSPU *render_spu )
{
CRConnection *conn;
int a;
for (a=0; a<256; a++)
{
render_spu->lut8[0][a] =
render_spu->lut8[1][a] =
render_spu->lut8[2][a] = a;
}
render_spu->use_lut8 = 0;
set_title(render_spu, "Chromium Render SPU");
set_window_geometry(render_spu, "[0, 0, 0, 0]");
set_fullscreen(render_spu, "0");
resizable(render_spu, "0");
set_on_top(render_spu, "1");
set_borderless(render_spu, "1");
set_default_visual(render_spu, "rgb, double, depth");
#if defined(GLX)
set_try_direct(render_spu, "1");
set_force_direct(render_spu, "0");
#endif
render_to_app_window(render_spu, "0");
render_to_crut_window(render_spu, "0");
set_cursor(render_spu, "0");
set_system_gl_path(render_spu, "");
set_display_string(render_spu, "DEFAULT");
gather_url(render_spu, "");
gather_userbuf(render_spu, "0");
set_lut8(render_spu, "");
set_master_url(render_spu, "");
set_is_master(render_spu, "0");
set_num_clients(render_spu, "1");
set_use_osmesa(render_spu, "0");
set_nv_swap_group(render_spu, "0");
set_ignore_papi(render_spu, "0");
set_ignore_window_moves(render_spu, "0");
set_pbuffer_size(render_spu, "[0, 0]");
set_use_glxchoosevisual(render_spu, "1");
set_draw_bbox(render_spu, "0");
render_spu->swap_mtu = 1024 * 500;
/* Some initialization that doesn't really have anything to do
* with configuration but which was done here before:
*/
render_spu->use_L2 = 0;
render_spu->cursorX = 0;
render_spu->cursorY = 0;
#if defined(GLX)
render_spu->sync = 0;
#endif
}
/**
* @brief Handle client messages that are related to WM_STATE.
*
* TODO: Add more WM_STATE hints.
*
* @param c The client that is to have its WM_STATE modified.
* @param a The atom representing which WM_STATE hint should be modified.
* @param action Whether to remove, add or toggle the WM_STATE hint.
*/
void ewmh_process_wm_state(Client *c, xcb_atom_t a, int action)
{
if (a == ewmh->_NET_WM_STATE_FULLSCREEN) {
if (action == _NET_WM_STATE_REMOVE)
set_fullscreen(c, false);
else if (action == _NET_WM_STATE_ADD)
set_fullscreen(c, true);
else if (action == _NET_WM_STATE_TOGGLE)
set_fullscreen(c, !c->is_fullscreen);
} else if (a == ewmh->_NET_WM_STATE_DEMANDS_ATTENTION) {
if (action == _NET_WM_STATE_REMOVE)
set_urgent(c, false);
else if (action == _NET_WM_STATE_ADD)
set_urgent(c, true);
else if (action == _NET_WM_STATE_TOGGLE)
set_urgent(c, !c->is_urgent);
} else {
log_warn("Unhandled wm state <%d> with action <%d>.", a, action);
}
}
static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t time, uint32_t key,
uint32_t state)
{
struct display *d = data;
if (key == KEY_F11 && state)
set_fullscreen(d->window, d->window->fullscreen ^ 1);
else if (key == KEY_ESC && state)
running = 0;
}
static int init(void) {
ps3InitDisplay();
LOG_DEBUG(2,"Initialising SDL video driver\n");
#ifdef WINDOWS32
if (!getenv("SDL_VIDEODRIVER"))
putenv("SDL_VIDEODRIVER=windib");
#endif
/* init SDL TTF */
TTF_Init();
text_fontSmall = TTF_OpenFont("/dev_hdd0/game/PS3Roar00/USRDIR/fonts/CenturySchoolBold.ttf", 10);
text_fontMedium = TTF_OpenFont("/dev_hdd0/game/PS3Roar00/USRDIR/fonts/CenturySchoolBold.ttf", 12);
text_fontLarge = TTF_OpenFont("/dev_hdd0/game/PS3Roar00/USRDIR/fonts/CenturySchoolBold.ttf", 18);
text_fontTiny = TTF_OpenFont("/dev_hdd0/game/PS3Roar00/USRDIR/fonts/CenturySchoolBold.ttf", 6);
backgroundScreen = IMG_Load("/dev_hdd0/game/PS3Roar00/USRDIR/images/oldtv_480phires.png");
egg = IMG_Load("/dev_hdd0/game/PS3Roar00/USRDIR/images/SUX.png");
if (!backgroundScreen)
{
printf("*********************************\n");
printf("**** Error Loading Image! *******\n");
printf("*********************************\n");
}
if (!SDL_WasInit(SDL_INIT_NOPARACHUTE)) {
if (SDL_Init(SDL_INIT_NOPARACHUTE) < 0) {
LOG_ERROR("Failed to initialise SDL: %s\n", SDL_GetError());
return 1;
}
}
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
LOG_ERROR("Failed to initialise SDL video driver: %s\n", SDL_GetError());
return 1;
}
if (set_fullscreen(xroar_fullscreen))
return 1;
#ifdef WINDOWS32
{
SDL_version sdlver;
SDL_SysWMinfo sdlinfo;
SDL_VERSION(&sdlver);
sdlinfo.version = sdlver;
SDL_GetWMInfo(&sdlinfo);
windows32_main_hwnd = sdlinfo.window;
}
#endif
set_mode(0);
/* Update screen with backround and display static */
SDL_UpdateRect(screen, 0, 0, 720, 480);
displayStatic(0);
return 0;
}
void show_preferences_dialog(display& disp, const config& game_cfg)
{
std::vector<std::string> items;
std::string const pre = IMAGE_PREFIX + std::string("icons/icon-");
char const sep = COLUMN_SEPARATOR;
items.push_back(pre + "general.png" + sep + sgettext("Prefs section^General"));
items.push_back(pre + "display.png" + sep + sgettext("Prefs section^Display"));
items.push_back(pre + "music.png" + sep + sgettext("Prefs section^Sound"));
items.push_back(pre + "multiplayer.png" + sep + sgettext("Prefs section^Multiplayer"));
items.push_back(pre + "advanced.png" + sep + sgettext("Advanced section^Advanced"));
for(;;) {
try {
preferences_dialog dialog(disp,game_cfg);
dialog.parent.assign(new preferences_parent_dialog(disp));
dialog.parent->set_menu(items);
dialog.parent->add_pane(&dialog);
dialog.parent->show();
return;
} catch(preferences_dialog::video_mode_change_exception& e) {
switch(e.type) {
case preferences_dialog::video_mode_change_exception::CHANGE_RESOLUTION:
show_video_mode_dialog(disp);
break;
case preferences_dialog::video_mode_change_exception::MAKE_FULLSCREEN:
set_fullscreen(true);
break;
case preferences_dialog::video_mode_change_exception::MAKE_WINDOWED:
set_fullscreen(false);
break;
}
if(items[1].empty() || items[1][0] != '*') {
items[1] = "*" + items[1];
}
}
}
}
void
handler_clientmessage_client(XClientMessageEvent *ev)
{
struct client *c;
if (!(c = find_client_by_window(mons, ev->window)))
return;
if (ev->message_type == atom(WMState)) {
DBG("%s: WMState\n", __func__);
} else if (ev->message_type == netatom(NetActiveWindow)) {
/* switch to the given client's monitor and workspace
* and set focus on the client when a NetActive event
* occurs. the spec is quite ambiguous about this. this
* behaviour might be changed */
set_monitor(c->mon);
monitor_select_client(c->mon, c, true);
} else if (ev->message_type == atom(WMChangeState)) {
if (ev->data.l[0] == IconicState && ev->format == 32) {
printf("%s: minimize window\n", __func__);
/* TODO: fix minimizing */
}
} else if (ev->message_type == netatom(NetDesktop)) {
unsigned long ws;
DBG("%s: NetDesktop\n", __func__);
/* TODO: handle multiple monitors */
if ((ws = ev->data.l[0]) != ALL_WS)
ws = ws % N_WORKSPACES;
client_set_ws(c, ws);
monitor_focus(c->mon, NULL);
monitor_arrange(c->mon);
} else if (ev->message_type == netatom(NetWMState)) {
if (ev->data.l[1] == netatom(NetWMFullscreen) ||
ev->data.l[2] == netatom(NetWMFullscreen)) {
bool fs = false;
if (ev->data.l[0] == NET_WM_STATE_ADD)
fs = true;
else if (ev->data.l[0] == NET_WM_STATE_TOGGLE)
fs = !c->fullscreen;
set_fullscreen(c, fs);
}
}
}
void
ConfigManager::apply(const Options& opts)
{
m_opts.merge(opts);
if (m_opts.framebuffer_type.is_set())
set_renderer(m_opts.framebuffer_type.get());
else
set_renderer(SDL_FRAMEBUFFER);
if (opts.master_volume.is_set())
set_master_volume(opts.master_volume.get());
if (opts.sound_volume.is_set())
set_sound_volume(opts.sound_volume.get());
if (opts.music_volume.is_set())
set_music_volume(opts.music_volume.get());
if (opts.fullscreen_resolution.is_set())
set_fullscreen_resolution(opts.fullscreen_resolution.get());
if (opts.fullscreen.is_set())
set_fullscreen(opts.fullscreen.get());
if (opts.resizable.is_set())
set_resizable(opts.resizable.get());
if (opts.mouse_grab.is_set())
set_mouse_grab(opts.mouse_grab.get());
if (opts.print_fps.is_set())
set_print_fps(opts.print_fps.get());
if (opts.software_cursor.is_set())
set_software_cursor(opts.software_cursor.get());
if (opts.auto_scrolling.is_set())
set_auto_scrolling(opts.auto_scrolling.get());
if (opts.language.is_set())
set_language(tinygettext::Language::from_env(opts.language.get()));
}
s8 wl_shell_surface_req(struct client *c,s32 shell_surface_slot,struct msg *m)
{
s8 r;
switch(m->req_op){
case WL_SHELL_SURFACE_PONG:
r=pong(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_MOVE:
r=move(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_RESIZE:
r=resize(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_TOP_LEVEL:
LOG_WIRE("client(%d):shell_surface::set_top_level shell_surface_id=%u\n",
c->so,m->req[0]);
r=shell_surface_set_top_level(c,shell_surface_slot);
break;
case WL_SHELL_SURFACE_SET_TRANSIENT:
r=set_transient(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_FULLSCREEN:
r=set_fullscreen(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_POPUP:
r=set_popup(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_MAXIMISED:
r=set_maximised(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_TITLE:
r=set_title(c,shell_surface_slot,m);
break;
case WL_SHELL_SURFACE_SET_CLASS:
r=set_class(c,shell_surface_slot,m);
break;
default:
PERR("client(%d):fatal:shell surface unknown opcode %u\n",c->so,m->req_op);
r=LWL_ERR;
};
return r;
}
void sdl_window_info::toggle_full_screen()
{
// if we are in debug mode, never go full screen
if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
return;
// If we are going fullscreen (leaving windowed) remember our windowed size
if (!fullscreen())
{
m_windowed_dim = get_size();
}
// reset UI to main menu
machine().ui().menu_reset();
// kill off the drawers
renderer_reset();
bool is_osx = false;
#ifdef SDLMAME_MACOSX
// FIXME: This is weird behaviour and certainly a bug in SDL
is_osx = true;
#endif
if (fullscreen() && (video_config.switchres || is_osx))
{
SDL_SetWindowFullscreen(platform_window(), 0); // Try to set mode
SDL_SetWindowDisplayMode(platform_window(), &m_original_mode->mode); // Try to set mode
SDL_SetWindowFullscreen(platform_window(), SDL_WINDOW_FULLSCREEN); // Try to set mode
}
SDL_DestroyWindow(platform_window());
set_platform_window(nullptr);
downcast<sdl_osd_interface &>(machine().osd()).release_keys();
set_renderer(osd_renderer::make_for_type(video_config.mode, shared_from_this()));
// toggle the window mode
set_fullscreen(!fullscreen());
complete_create();
}
void client_message(xcb_generic_event_t *evt)
{
xcb_client_message_event_t *e = (xcb_client_message_event_t *) evt;
PRINTF("client message %X %u\n", e->window, e->type);
if (e->type == ewmh->_NET_CURRENT_DESKTOP) {
coordinates_t loc;
if (ewmh_locate_desktop(e->data.data32[0], &loc))
focus_node(loc.monitor, loc.desktop, loc.desktop->focus);
return;
}
coordinates_t loc;
if (!locate_window(e->window, &loc))
return;
if (e->type == ewmh->_NET_WM_STATE) {
handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[1], e->data.data32[0]);
handle_state(loc.monitor, loc.desktop, loc.node, e->data.data32[2], e->data.data32[0]);
} else if (e->type == ewmh->_NET_ACTIVE_WINDOW) {
if ((ignore_ewmh_focus && e->data.data32[0] == XCB_EWMH_CLIENT_SOURCE_TYPE_NORMAL) ||
loc.node == mon->desk->focus)
return;
if (loc.desktop->focus->client->fullscreen && loc.desktop->focus != loc.node) {
set_fullscreen(loc.desktop->focus, false);
arrange(loc.monitor, loc.desktop);
}
focus_node(loc.monitor, loc.desktop, loc.node);
} else if (e->type == ewmh->_NET_WM_DESKTOP) {
coordinates_t dloc;
if (ewmh_locate_desktop(e->data.data32[0], &dloc))
transfer_node(loc.monitor, loc.desktop, loc.node, dloc.monitor, dloc.desktop, dloc.desktop->focus);
} else if (e->type == ewmh->_NET_CLOSE_WINDOW) {
window_close(loc.node);
}
}
void CL_DisplayWindow_OpenGL::create_window(const CL_DisplayWindowDescription &desc)
{
OSStatus result;
const CL_OpenGLWindowDescription_Generic *gl_desc = 0;
gl_desc = dynamic_cast<const CL_OpenGLWindowDescription_Generic*>(desc.impl.get());
fullscreen_width = desc.get_size().width;
fullscreen_height = desc.get_size().height;
disp_ref_count++;
GLint gl_attribs_single[] =
{
AGL_RGBA,
AGL_RED_SIZE, 4,
AGL_GREEN_SIZE, 4,
AGL_BLUE_SIZE, 4,
AGL_DEPTH_SIZE, 16,
AGL_NONE
};
GLint gl_attribs[32];
int i = 0;
if( gl_desc )
{
if( gl_desc->rgba ) gl_attribs[i++] = AGL_RGBA;
if( gl_desc->doublebuffer ) gl_attribs[i++] = AGL_DOUBLEBUFFER;
//if( gl_desc->stereo ) gl_attribs[i++] = AGL_STEREO;
gl_attribs[i++] = AGL_BUFFER_SIZE;
gl_attribs[i++] = gl_desc->buffer_size;
gl_attribs[i++] = AGL_LEVEL;
gl_attribs[i++] = gl_desc->level;
gl_attribs[i++] = AGL_AUX_BUFFERS;
gl_attribs[i++] = gl_desc->aux_buffers;
gl_attribs[i++] = AGL_RED_SIZE;
gl_attribs[i++] = gl_desc->red_size;
gl_attribs[i++] = AGL_GREEN_SIZE;
gl_attribs[i++] = gl_desc->green_size;
gl_attribs[i++] = AGL_BLUE_SIZE;
gl_attribs[i++] = gl_desc->blue_size;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = gl_desc->depth_size;
gl_attribs[i++] = AGL_STENCIL_SIZE;
gl_attribs[i++] = gl_desc->stencil_size;
gl_attribs[i++] = AGL_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
gl_attribs[i++] = AGL_ACCUM_GREEN_SIZE;
gl_attribs[i++] = gl_desc->accum_green_size;
gl_attribs[i++] = AGL_ACCUM_BLUE_SIZE;
gl_attribs[i++] = gl_desc->accum_blue_size;
gl_attribs[i++] = AGL_ACCUM_ALPHA_SIZE;
gl_attribs[i++] = gl_desc->accum_alpha_size;
gl_attribs[i++] = AGL_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
// gl_attribs[i++] = AGL_FULLSCREEN;
}
else
{
gl_attribs[i++] = AGL_RGBA;
gl_attribs[i++] = AGL_NO_RECOVERY;
gl_attribs[i++] = AGL_DOUBLEBUFFER;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = 16;
}
/*
else
{
gl_attribs[i++] = AGL_RGBA;
gl_attribs[i++] = AGL_DOUBLEBUFFER;
gl_attribs[i++] = AGL_RED_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_GREEN_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_BLUE_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = 16;
// gl_attribs[i++] = AGL_FULLSCREEN;
}
*/
gl_attribs[i] = AGL_NONE;
CGDirectDisplayID display = CGMainDisplayID();
GDHandle gdhDisplay, *pgdhDisplay;
int numDisplay;
pgdhDisplay = &gdhDisplay;
if (noErr == DMGetGDeviceByDisplayID ((DisplayIDType)display, pgdhDisplay, false))
numDisplay = 1;
else
{
pgdhDisplay = 0;
numDisplay = 0;
}
AGLPixelFormat pixelformat;
pixelformat = aglChoosePixelFormat(pgdhDisplay, numDisplay, gl_attribs);
win_context = aglCreateContext(pixelformat, share_context);
if (!share_context) share_context = win_context;
aglDestroyPixelFormat(pixelformat);
gl_attribs[i++] = AGL_FULLSCREEN;
gl_attribs[i] = AGL_NONE;
pixelformat = aglChoosePixelFormat(pgdhDisplay, numDisplay, gl_attribs);
fs_context = aglCreateContext(pixelformat, win_context);
aglDestroyPixelFormat(pixelformat);
if (!(win_context && fs_context))
{
printf("Requested visual not supported by your OpenGL implementation. Falling back on singlebuffered Visual!\n");
pixelformat = aglChoosePixelFormat(0, 0, gl_attribs_single);
win_context = aglCreateContext(pixelformat, share_context);
aglDestroyPixelFormat(pixelformat);
fs_context = 0;
}
WindowAttributes style = kWindowCloseBoxAttribute | kWindowStandardHandlerAttribute;
if (desc.get_allow_resize()) style |= kWindowResizableAttribute | kWindowFullZoomAttribute;
Rect window_rect;
SetRect(&window_rect, 50, 50, 50+desc.get_size().width, 50+desc.get_size().height);
result = CreateNewWindow(kDocumentWindowClass, style, &window_rect, &window_ref);
if (result != noErr)
printf("Could not create window, due to error %d\n", (int)result);
// set title of window:
set_title(desc.get_title());
// Set standard arrow cursor:
InitCursor(); // do we need to do this? -- iMBN, 13. may 2004
// Create input devices for window:
keyboard = CL_InputDevice(new CL_InputDevice_MacKeyboard(this));
mouse = CL_InputDevice(new CL_InputDevice_MacMouse(this));
get_ic()->clear();
get_ic()->add_keyboard(keyboard);
get_ic()->add_mouse(mouse);
// buffer_front = CL_PixelBuffer(new CL_PixelBuffer_OpenGL_Frame(CL_FRONT, gc));
// buffer_back = CL_PixelBuffer(new CL_PixelBuffer_OpenGL_Frame(CL_BACK, gc));
if (!aglSetDrawable(win_context, GetWindowPort(window_ref)))
{
printf("Unable to set drawable");
}
if (desc.is_fullscreen())
set_fullscreen(desc.get_size().width, desc.get_size().height, desc.get_bpp(), desc.get_refresh_rate());
else {
fullscreen = true; // not really, but need to fool set_windowed
set_windowed();
}
ShowWindow(window_ref);
}
static bool gfx_ctx_set_video_mode(
unsigned width, unsigned height,
bool fullscreen)
{
DWORD style;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
MONITORINFOEX current_mon;
monitor_info(¤t_mon, &hm_to_use);
RECT mon_rect = current_mon.rcMonitor;
g_resize_width = width;
g_resize_height = height;
bool windowed_full = g_settings.video.windowed_fullscreen;
if (fullscreen)
{
if (windowed_full)
{
style = WS_EX_TOPMOST | WS_POPUP;
g_resize_width = width = mon_rect.right - mon_rect.left;
g_resize_height = height = mon_rect.bottom - mon_rect.top;
}
else
{
style = WS_POPUP | WS_VISIBLE;
if (!set_fullscreen(width, height, current_mon.szDevice))
goto error;
// display settings might have changed, get new coordinates
GetMonitorInfo(hm_to_use, (MONITORINFO*)¤t_mon);
mon_rect = current_mon.rcMonitor;
g_restore_desktop = true;
}
}
else
{
style = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
rect.right = width;
rect.bottom = height;
AdjustWindowRect(&rect, style, FALSE);
width = rect.right - rect.left;
height = rect.bottom - rect.top;
}
g_hwnd = CreateWindowEx(0, "RetroArch", "RetroArch", style,
fullscreen ? mon_rect.left : g_pos_x,
fullscreen ? mon_rect.top : g_pos_y,
width, height,
NULL, NULL, NULL, NULL);
if (!g_hwnd)
goto error;
if (!fullscreen)
{
SetMenu(g_hwnd, LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(IDR_MENU)));
RECT rcTemp = {0, 0, g_resize_height, 0x7FFF}; // 0x7FFF="Infinite" height
SendMessage(g_hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rcTemp); // recalculate margin, taking possible menu wrap into account
g_resize_height += rcTemp.top + rect.top; // extend by new top margin and substract previous margin
SetWindowPos(g_hwnd, NULL, 0, 0, g_resize_width, g_resize_height, SWP_NOMOVE);
}
if (!fullscreen || windowed_full)
{
ShowWindow(g_hwnd, SW_RESTORE);
UpdateWindow(g_hwnd);
SetForegroundWindow(g_hwnd);
SetFocus(g_hwnd);
}
show_cursor(!fullscreen);
// Wait until GL context is created (or failed to do so ...)
MSG msg;
while (!g_inited && !g_quit && GetMessage(&msg, g_hwnd, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_quit)
goto error;
p_swap_interval = (BOOL (APIENTRY *)(int))wglGetProcAddress("wglSwapIntervalEXT");
gfx_ctx_swap_interval(g_interval);
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)g_hwnd;
return true;
error:
gfx_ctx_destroy();
return false;
}
LRESULT CALLBACK winwindow_video_window_proc(HWND wnd, UINT message, WPARAM wparam, LPARAM lparam)
{
LONG_PTR ptr = GetWindowLongPtr(wnd, GWLP_USERDATA);
win_window_info *window = (win_window_info *)ptr;
// we may get called before SetWindowLongPtr is called
if (window != NULL)
{
assert(GetCurrentThreadId() == window_threadid);
update_minmax_state(window);
}
// handle a few messages
switch (message)
{
// paint: redraw the last bitmap
case WM_PAINT:
{
PAINTSTRUCT pstruct;
HDC hdc = BeginPaint(wnd, &pstruct);
draw_video_contents(window, hdc, TRUE);
if (win_has_menu(window))
DrawMenuBar(window->hwnd);
EndPaint(wnd, &pstruct);
break;
}
// non-client paint: punt if full screen
case WM_NCPAINT:
if (!window->fullscreen || HAS_WINDOW_MENU)
return DefWindowProc(wnd, message, wparam, lparam);
break;
// input: handle the raw mouse input
case WM_INPUT:
if (win_use_raw_mouse)
win_raw_mouse_update((HRAWINPUT)lparam);
break;
// syskeys - ignore
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
break;
// pause the system when we start a menu or resize
case WM_ENTERSIZEMOVE:
window->resize_state = RESIZE_STATE_RESIZING;
case WM_ENTERMENULOOP:
winwindow_ui_pause_from_window_thread(TRUE);
break;
// unpause the system when we stop a menu or resize and force a redraw
case WM_EXITSIZEMOVE:
window->resize_state = RESIZE_STATE_PENDING;
case WM_EXITMENULOOP:
winwindow_ui_pause_from_window_thread(FALSE);
InvalidateRect(wnd, NULL, FALSE);
break;
// get min/max info: set the minimum window size
case WM_GETMINMAXINFO:
{
MINMAXINFO *minmax = (MINMAXINFO *)lparam;
minmax->ptMinTrackSize.x = MIN_WINDOW_DIM;
minmax->ptMinTrackSize.y = MIN_WINDOW_DIM;
break;
}
// sizing: constrain to the aspect ratio unless control key is held down
case WM_SIZING:
{
RECT *rect = (RECT *)lparam;
if (video_config.keepaspect && !(GetAsyncKeyState(VK_CONTROL) & 0x8000))
constrain_to_aspect_ratio(window, rect, wparam);
InvalidateRect(wnd, NULL, FALSE);
break;
}
// syscommands: catch win_start_maximized
case WM_SYSCOMMAND:
{
// prevent screensaver or monitor power events
if (wparam == SC_MONITORPOWER || wparam == SC_SCREENSAVE)
return 1;
// most SYSCOMMANDs require us to invalidate the window
InvalidateRect(wnd, NULL, FALSE);
// handle maximize
if ((wparam & 0xfff0) == SC_MAXIMIZE)
{
update_minmax_state(window);
if (window->ismaximized)
minimize_window(window);
else
maximize_window(window);
break;
}
return DefWindowProc(wnd, message, wparam, lparam);
}
// track whether we are in the foreground
case WM_ACTIVATEAPP:
in_background = !wparam;
break;
// close: cause MAME to exit
case WM_CLOSE:
if (multithreading_enabled)
PostThreadMessage(main_threadid, WM_USER_REQUEST_EXIT, 0, 0);
else
mame_schedule_exit(Machine);
break;
// destroy: clean up all attached rendering bits and NULL out our hwnd
case WM_DESTROY:
(*draw.window_destroy)(window);
window->hwnd = NULL;
return DefWindowProc(wnd, message, wparam, lparam);
// self redraw: draw ourself in a non-painty way
case WM_USER_REDRAW:
{
HDC hdc = GetDC(wnd);
mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW begin");
window->primlist = (const render_primitive_list *)lparam;
draw_video_contents(window, hdc, FALSE);
mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW end");
ReleaseDC(wnd, hdc);
break;
}
// self destruct
case WM_USER_SELF_TERMINATE:
DestroyWindow(window->hwnd);
break;
// fullscreen set
case WM_USER_SET_FULLSCREEN:
set_fullscreen(window, wparam);
break;
// minimum size set
case WM_USER_SET_MINSIZE:
minimize_window(window);
break;
// maximum size set
case WM_USER_SET_MAXSIZE:
maximize_window(window);
break;
// set focus: if we're not the primary window, switch back
// commented out ATM because this prevents us from resizing secondary windows
// case WM_SETFOCUS:
// if (window != win_window_list && win_window_list != NULL)
// SetFocus(win_window_list->hwnd);
// break;
// everything else: defaults
default:
return DefWindowProc(wnd, message, wparam, lparam);
}
return 0;
}
void CL_DisplayWindow_OpenGL::create_window(const CL_DisplayWindowDescription &desc)
{
const CL_OpenGLWindowDescription_Generic *gl_desc = 0;
gl_desc = dynamic_cast<const CL_OpenGLWindowDescription_Generic*>(desc.impl.get());
fullscreen_width = desc.get_size().width;
fullscreen_height = desc.get_size().height;
XVisualInfo *vi;
Colormap cmap;
if (disp == 0)
{
disp = XOpenDisplay(0);
if (disp == 0) throw CL_Error("Could not open X11 display!");
}
disp_ref_count++;
int gl_attribs_single[] =
{
GLX_RGBA,
GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
GLX_DEPTH_SIZE, 16,
None
};
int gl_attribs[32];
int i = 0;
if( gl_desc )
{
if( gl_desc->rgba ) gl_attribs[i++] = GLX_RGBA;
if( gl_desc->doublebuffer ) gl_attribs[i++] = GLX_DOUBLEBUFFER;
if( gl_desc->stereo ) gl_attribs[i++] = GLX_STEREO;
gl_attribs[i++] = GLX_BUFFER_SIZE;
gl_attribs[i++] = gl_desc->buffer_size;
gl_attribs[i++] = GLX_LEVEL;
gl_attribs[i++] = gl_desc->level;
gl_attribs[i++] = GLX_AUX_BUFFERS;
gl_attribs[i++] = gl_desc->aux_buffers;
gl_attribs[i++] = GLX_RED_SIZE;
gl_attribs[i++] = gl_desc->red_size;
gl_attribs[i++] = GLX_GREEN_SIZE;
gl_attribs[i++] = gl_desc->green_size;
gl_attribs[i++] = GLX_BLUE_SIZE;
gl_attribs[i++] = gl_desc->blue_size;
gl_attribs[i++] = GLX_DEPTH_SIZE;
gl_attribs[i++] = gl_desc->depth_size;
gl_attribs[i++] = GLX_STENCIL_SIZE;
gl_attribs[i++] = gl_desc->stencil_size;
gl_attribs[i++] = GLX_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
gl_attribs[i++] = GLX_ACCUM_GREEN_SIZE;
gl_attribs[i++] = gl_desc->accum_green_size;
gl_attribs[i++] = GLX_ACCUM_BLUE_SIZE;
gl_attribs[i++] = gl_desc->accum_blue_size;
gl_attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
gl_attribs[i++] = gl_desc->accum_alpha_size;
gl_attribs[i++] = GLX_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
gl_attribs[i++] = None;
}
else
{
gl_attribs[i++] = GLX_RGBA;
gl_attribs[i++] = GLX_DOUBLEBUFFER;
gl_attribs[i++] = GLX_RED_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = GLX_GREEN_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = GLX_BLUE_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = GLX_DEPTH_SIZE;
gl_attribs[i++] = 16;
gl_attribs[i++] = None;
}
// get an appropriate visual
vi = glXChooseVisual(disp, DefaultScreen(disp), gl_attribs);
if (vi == NULL)
{
vi = glXChooseVisual(disp, window, gl_attribs_single);
printf("Requested visual not supported by your OpenGL implementation. Falling back on singlebuffered Visual!\n");
}
// create a GLX context
context = glXCreateContext(disp, vi, share_context, True);
if( share_context == NULL )
share_context = context;
glXGetConfig(disp, vi, GLX_BUFFER_SIZE, &glx_bpp);
// create a color map
cmap = XCreateColormap( disp, RootWindow(disp, vi->screen), vi->visual, AllocNone);
attributes.colormap = cmap;
attributes.border_pixel = 0;
attributes.override_redirect = False;
// create a window in window mode
attributes.event_mask =
ExposureMask |
KeyPressMask |
KeyReleaseMask |
ButtonPressMask |
ButtonReleaseMask |
StructureNotifyMask |
PointerMotionMask |
EnterWindowMask |
LeaveWindowMask |
FocusChangeMask;
window = XCreateWindow(disp, RootWindow(disp, vi->screen),
0, 0, desc.get_size().width, desc.get_size().height, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWOverrideRedirect | CWEventMask, &attributes);
XSelectInput(disp, window,
FocusChangeMask | KeyPressMask | KeyReleaseMask
| PropertyChangeMask | StructureNotifyMask |
KeymapStateMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask);
// set title of window:
set_title(desc.get_title());
// setup size hints:
XSizeHints size_hints;
memset(&size_hints, 0, sizeof(XSizeHints));
size_hints.width = desc.get_size().width;
size_hints.height = desc.get_size().height;
size_hints.base_width = desc.get_size().width;
size_hints.base_height = desc.get_size().height;
size_hints.min_width = size_hints.width;
size_hints.min_height = size_hints.height;
size_hints.max_width = size_hints.width;
size_hints.max_height = size_hints.height;
size_hints.flags = PSize|PBaseSize;
if (!desc.get_allow_resize()) size_hints.flags |= PMinSize | PMaxSize;
XSetWMNormalHints(disp, window, &size_hints);
// handle wm_delete_events if in windowed mode:
Atom wm_delete = XInternAtom(disp, "WM_DELETE_WINDOW", True);
XSetWMProtocols(disp, window, &wm_delete, 1);
// make window visible:
XMapRaised(disp, window);
if (!glXIsDirect(disp, context))
printf("No hardware acceleration available. I hope you got a really fast machine..\n");
// Create input devices for window:
keyboard = CL_InputDevice(new CL_InputDevice_X11Keyboard(this));
mouse = CL_InputDevice(new CL_InputDevice_X11Mouse(this));
get_ic()->clear();
get_ic()->add_keyboard(keyboard);
get_ic()->add_mouse(mouse);
setup_joysticks();
// setup_usb_mice();
// setup_xinput();
// setup_event();
XSync(disp, True);
focus = true;
system_cursor = XCreateFontCursor(disp, XC_left_ptr);
char *data = (char*)malloc(64); // 8x8
memset(data, 0, 64);
XColor black_color;
memset(&black_color, 0, sizeof(black_color));
cursor_bitmap = XCreateBitmapFromData(disp, window, data, 8, 8);
hidden_cursor = XCreatePixmapCursor(disp, cursor_bitmap, cursor_bitmap, &black_color, &black_color, 0,0 );
if (desc.is_fullscreen())
set_fullscreen(desc.get_size().width, desc.get_size().height, desc.get_bpp(), desc.get_refresh_rate());
}
static bool gfx_ctx_wgl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
DWORD style;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
MONITORINFOEX current_mon;
monitor_info(¤t_mon, &hm_to_use);
RECT mon_rect = current_mon.rcMonitor;
g_resize_width = width;
g_resize_height = height;
bool windowed_full = g_settings.video.windowed_fullscreen;
if (fullscreen)
{
if (windowed_full)
{
style = WS_EX_TOPMOST | WS_POPUP;
g_resize_width = width = mon_rect.right - mon_rect.left;
g_resize_height = height = mon_rect.bottom - mon_rect.top;
}
else
{
style = WS_POPUP | WS_VISIBLE;
if (!set_fullscreen(width, height, current_mon.szDevice))
goto error;
// display settings might have changed, get new coordinates
GetMonitorInfo(hm_to_use, (MONITORINFO*)¤t_mon);
mon_rect = current_mon.rcMonitor;
g_restore_desktop = true;
}
}
else
{
style = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
rect.right = width;
rect.bottom = height;
AdjustWindowRect(&rect, style, FALSE);
width = rect.right - rect.left;
height = rect.bottom - rect.top;
}
g_hwnd = CreateWindowEx(0, "RetroArch", "RetroArch", style,
fullscreen ? mon_rect.left : g_pos_x,
fullscreen ? mon_rect.top : g_pos_y,
width, height,
NULL, NULL, NULL, NULL);
if (!g_hwnd)
goto error;
if (!fullscreen || windowed_full)
{
ShowWindow(g_hwnd, SW_RESTORE);
UpdateWindow(g_hwnd);
SetForegroundWindow(g_hwnd);
SetFocus(g_hwnd);
}
show_cursor(!fullscreen);
// Wait until GL context is created (or failed to do so ...)
MSG msg;
while (!g_inited && !g_quit && GetMessage(&msg, g_hwnd, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_quit)
goto error;
p_swap_interval = (BOOL (APIENTRY *)(int))wglGetProcAddress("wglSwapIntervalEXT");
gfx_ctx_wgl_swap_interval(data, g_interval);
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)g_hwnd;
return true;
error:
gfx_ctx_wgl_destroy(data);
return false;
}
static void shutdown(void) {
LOG_DEBUG(2,"Shutting down SDL video driver\n");
set_fullscreen(0);
/* Should not be freed by caller: SDL_FreeSurface(screen); */
SDL_QuitSubSystem(SDL_INIT_VIDEO);
}
void GTKVideo::toggle_fullscreen() {
if (is_fullscreen_)
set_fullscreen(FALSE, this);
else
set_fullscreen(TRUE, this);
}
static bool gfx_ctx_wgl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
DWORD style;
MSG msg;
RECT mon_rect;
MONITORINFOEX current_mon;
float refresh_mod;
unsigned refresh;
bool windowed_full;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
monitor_info(¤t_mon, &hm_to_use);
mon_rect = current_mon.rcMonitor;
g_resize_width = width;
g_resize_height = height;
/* Windows only reports the refresh rates for modelines as
* an integer, so video.refresh_rate needs to be rounded. Also, account
* for black frame insertion using video.refresh_rate set to half
* of the display refresh rate. */
refresh_mod = settings->video.black_frame_insertion ? 2.0f : 1.0f;
refresh = round(settings->video.refresh_rate * refresh_mod);
windowed_full = settings->video.windowed_fullscreen;
if (fullscreen)
{
if (windowed_full)
{
style = WS_EX_TOPMOST | WS_POPUP;
g_resize_width = width = mon_rect.right - mon_rect.left;
g_resize_height = height = mon_rect.bottom - mon_rect.top;
}
else
{
style = WS_POPUP | WS_VISIBLE;
if (!set_fullscreen(width, height, refresh, current_mon.szDevice))
goto error;
/* Display settings might have changed, get new coordinates. */
GetMonitorInfo(hm_to_use, (MONITORINFO*)¤t_mon);
mon_rect = current_mon.rcMonitor;
g_restore_desktop = true;
}
}
else
{
style = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
rect.right = width;
rect.bottom = height;
AdjustWindowRect(&rect, style, FALSE);
g_resize_width = width = rect.right - rect.left;
g_resize_height = height = rect.bottom - rect.top;
}
g_hwnd = CreateWindowEx(0, "RetroArch", "RetroArch", style,
fullscreen ? mon_rect.left : g_pos_x,
fullscreen ? mon_rect.top : g_pos_y,
width, height,
NULL, NULL, NULL, NULL);
if (!g_hwnd)
goto error;
if (!fullscreen || windowed_full)
{
if (!fullscreen && settings->ui.menubar_enable)
{
RECT rc_temp = {0, 0, (LONG)height, 0x7FFF};
SetMenu(g_hwnd, LoadMenu(GetModuleHandle(NULL),MAKEINTRESOURCE(IDR_MENU)));
SendMessage(g_hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rc_temp);
g_resize_height = height += rc_temp.top + rect.top;
SetWindowPos(g_hwnd, NULL, 0, 0, width, height, SWP_NOMOVE);
}
ShowWindow(g_hwnd, SW_RESTORE);
UpdateWindow(g_hwnd);
SetForegroundWindow(g_hwnd);
SetFocus(g_hwnd);
}
win32_show_cursor(!fullscreen);
/* Wait until GL context is created (or failed to do so ...) */
while (!g_inited && !g_quit && GetMessage(&msg, g_hwnd, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (g_quit)
goto error;
p_swap_interval = (BOOL (APIENTRY *)(int))wglGetProcAddress("wglSwapIntervalEXT");
gfx_ctx_wgl_swap_interval(data, g_interval);
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)g_hwnd;
return true;
error:
gfx_ctx_wgl_destroy(data);
return false;
}
int
main(int argc, char *argv[])
{
EGLint egl_major, egl_minor;
EGLConfig config;
EGLint num_config;
EGLContext context;
GLuint vertex_shader;
GLuint fragment_shader;
GLuint program;
GLint ret;
GLint width, height;
#ifdef USE_X
XDisplay = XOpenDisplay(NULL);
if (!XDisplay) {
fprintf(stderr, "Error: failed to open X display.\n");
return -1;
}
Window XRoot = DefaultRootWindow(XDisplay);
XSetWindowAttributes XWinAttr;
XWinAttr.event_mask = ExposureMask | PointerMotionMask;
XWindow = XCreateWindow(XDisplay, XRoot, 0, 0, WIDTH, HEIGHT, 0,
CopyFromParent, InputOutput,
CopyFromParent, CWEventMask, &XWinAttr);
XMapWindow(XDisplay, XWindow);
XStoreName(XDisplay, XWindow, "Mali libs test");
egl_display = eglGetDisplay((EGLNativeDisplayType) XDisplay);
#else
egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
#endif /* USE_X */
if (egl_display == EGL_NO_DISPLAY) {
fprintf(stderr, "Error: No display found!\n");
return -1;
}
if (!eglInitialize(egl_display, &egl_major, &egl_minor)) {
fprintf(stderr, "Error: eglInitialise failed!\n");
return -1;
}
printf("EGL Version: \"%s\"\n",
eglQueryString(egl_display, EGL_VERSION));
printf("EGL Vendor: \"%s\"\n",
eglQueryString(egl_display, EGL_VENDOR));
printf("EGL Extensions: \"%s\"\n",
eglQueryString(egl_display, EGL_EXTENSIONS));
eglChooseConfig(egl_display, config_attribute_list, &config, 1,
&num_config);
context = eglCreateContext(egl_display, config, EGL_NO_CONTEXT,
context_attribute_list);
if (context == EGL_NO_CONTEXT) {
fprintf(stderr, "Error: eglCreateContext failed: 0x%08X\n",
eglGetError());
return -1;
}
#ifdef USE_X
egl_surface = eglCreateWindowSurface(egl_display, config,
(void *) XWindow,
window_attribute_list);
#else
egl_surface = eglCreateWindowSurface(egl_display, config,
&native_window,
window_attribute_list);
#endif
if (egl_surface == EGL_NO_SURFACE) {
fprintf(stderr, "Error: eglCreateWindowSurface failed: "
"0x%08X\n", eglGetError());
return -1;
}
if (!eglQuerySurface(egl_display, egl_surface, EGL_WIDTH, &width) ||
!eglQuerySurface(egl_display, egl_surface, EGL_HEIGHT, &height)) {
fprintf(stderr, "Error: eglQuerySurface failed: 0x%08X\n",
eglGetError());
return -1;
}
printf("Surface size: %dx%d\n", width, height);
if (!eglMakeCurrent(egl_display, egl_surface, egl_surface, context)) {
fprintf(stderr, "Error: eglMakeCurrent() failed: 0x%08X\n",
eglGetError());
return -1;
}
printf("GL Vendor: \"%s\"\n", glGetString(GL_VENDOR));
printf("GL Renderer: \"%s\"\n", glGetString(GL_RENDERER));
printf("GL Version: \"%s\"\n", glGetString(GL_VERSION));
printf("GL Extensions: \"%s\"\n", glGetString(GL_EXTENSIONS));
printf("\nNow you should see the animation with 1 FPS framerate\n");
printf("of the screen changing background color between yellow\n");
printf("and blue (starting with yellow). Based on the timing\n");
printf("of going fullscreen, it may expose xf86-video-mali bug.\n");
set_fullscreen();
Redraw(width, height);
#ifdef USE_X
while (1) {
Redraw(width, height);
}
#endif
return 0;
}
void QWaylandShellSurface::setFullscreen()
{
m_fullscreen = true;
m_size = m_window->window()->geometry().size();
set_fullscreen(0, 0, 0);
}
void keyboard( unsigned char key, int x, int y )
{
if( isupper(key) )
key = tolower(key);
switch( key )
{
case 'a':
if( anim )
stop();
else
start();
break;
case 'c': reset_camera(); break;
case 'f': fps_status = !fps_status; break;
case 'g': gridon = !gridon; break;
case 'p': planeon = !planeon; break;
case 'h': half = !half; break;
case 'l':
lights = !lights;
if( lights )
glEnable(GL_LIGHTING);
else
glDisable(GL_LIGHTING);
break;
case 'b':
cull = !cull;
if( cull )
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
break;
case 'o':
ortho = !ortho;
set_projection();
break;
case 's':
smooth = !smooth;
glShadeModel(smooth ? GL_SMOOTH : GL_FLAT);
break;
case 'w':
wire = !wire;
glPolygonMode(GL_FRONT_AND_BACK, wire ? GL_LINE : GL_FILL);
break;
case ' ':
fullscreen = !fullscreen;
set_fullscreen();
break;
case '\t':
printf("\ncamera:\n"
"-------------------\n"
"%3.3f elev\n"
"%3.3f azim\n"
"%3.3f dist\n"
"%3.3f x\n"
"%3.3f y\n",
cam_elev,
cam_azim,
cam_dist,
cam_panx,
cam_pany );
break;
case 'q': exit(0); break;
default:
print_help();
break;
}
// refresh after a command
glutPostRedisplay();
}
void QWaylandWlShellSurface::setFullscreen()
{
m_fullscreen = true;
m_size = m_window->window()->geometry().size();
set_fullscreen(WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, 0);
}
virtual bool set_fullscreen0() { return set_fullscreen(); }
static void
function_toggle_fullscreen(int x, int y)
{
set_fullscreen(!get_fullscreen());
}
