void Loop(Window target)
{
Window root;
int x,y,border_width,depth;
XEvent Event;
int tw,th;
char *temp;
char *prop = NULL;
Atom actual = None;
int actual_format;
unsigned long nitems, bytesafter;
while(1)
{
XNextEvent(dpy,&Event);
switch(Event.type)
{
case Expose:
exposed = 1;
RedrawWindow(target);
break;
case ConfigureNotify:
XGetGeometry(dpy,main_win,&root,&x,&y,
(unsigned int *)&tw,(unsigned int *)&th,
(unsigned int *)&border_width,
(unsigned int *)&depth);
if((tw != Width)||(th!= Height))
{
XResizeWindow(dpy,holder_win,tw-BAR_WIDTH-PAD_WIDTH3,
th-BAR_WIDTH-PAD_WIDTH3);
Width = tw;
Height = th;
if(target_y_offset + Height - BAR_WIDTH > target_height)
target_y_offset = target_height - Height + BAR_WIDTH;
if(target_y_offset < 0)
target_y_offset = 0;
if(target_x_offset < 0)
target_x_offset = 0;
if(target_x_offset + Width - BAR_WIDTH > target_width)
target_x_offset = target_width - Width + BAR_WIDTH;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
exposed = 1;
RedrawWindow(target);
}
break;
case ButtonPress:
if((Event.xbutton.y > Height-BAR_WIDTH) &&
(Event.xbutton.x < SCROLL_BAR_WIDTH+PAD_WIDTH3))
{
motion = LEFT;
exposed = 2;
RedrawWindow(target);
}
else if((Event.xbutton.y > Height-BAR_WIDTH) &&
(Event.xbutton.x > Width-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
(Event.xbutton.x < Width-BAR_WIDTH))
{
motion = RIGHT;
exposed = 2;
RedrawWindow(target);
}
else if((Event.xbutton.y < SCROLL_BAR_WIDTH+PAD_WIDTH3) &&
(Event.xbutton.x > Width-BAR_WIDTH))
{
motion = TOP;
exposed = 2;
RedrawWindow(target);
}
else if((Event.xbutton.y > Height-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
(Event.xbutton.y < Height-BAR_WIDTH)&&
(Event.xbutton.x > Width-BAR_WIDTH))
{
motion = BOTTOM;
exposed = 2;
RedrawWindow(target);
}
else if((Event.xbutton.x > Width - BAR_WIDTH)&&
(Event.xbutton.y < Height- BAR_WIDTH))
{
motion = VERTICAL;
target_y_offset=(Event.xbutton.y-PAD_WIDTH3-SCROLL_BAR_WIDTH)*
target_height/
(Height-BAR_WIDTH-PAD_WIDTH3 - 2*SCROLL_BAR_WIDTH);
if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 > target_height)
target_y_offset = target_height - Height+BAR_WIDTH+PAD_WIDTH3;
if(target_y_offset < 0)
target_y_offset = 0;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
RedrawWindow(target);
}
else if((Event.xbutton.y > Height- BAR_WIDTH ) &&
(Event.xbutton.x < Width- BAR_WIDTH))
{
motion=HORIZONTAL;
target_x_offset=(Event.xbutton.x -PAD_WIDTH3-SCROLL_BAR_WIDTH)*
target_width/
(Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH);
if(target_x_offset < 0)
target_x_offset = 0;
if(target_x_offset + Width - BAR_WIDTH -PAD_WIDTH3> target_width)
target_x_offset = target_width - Width + BAR_WIDTH+PAD_WIDTH3;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
RedrawWindow(target);
}
else if((Event.xbutton.y > Height- BAR_WIDTH ) &&
(Event.xbutton.x > Width- BAR_WIDTH))
{
exposed = 2;
motion=QUIT;
}
RedrawWindow(target);
break;
case ButtonRelease:
if((Event.xbutton.y > Height- BAR_WIDTH ) &&
(Event.xbutton.x > Width- BAR_WIDTH)&&
(motion==QUIT))
{
XUnmapWindow(dpy,main_win);
XReparentWindow(dpy,target,Root,x,y);
XSync(dpy,0);
exit(0);
}
if((motion == LEFT)&&(Event.xbutton.y > Height-BAR_WIDTH) &&
(Event.xbutton.x < SCROLL_BAR_WIDTH+PAD_WIDTH3))
{
target_x_offset -= (Width-BAR_WIDTH-PAD_WIDTH2);
if(target_x_offset < 0)
target_x_offset = 0;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
motion = NONE;
exposed = 2;
}
else if((motion == RIGHT)&&(Event.xbutton.y > Height-BAR_WIDTH) &&
(Event.xbutton.x > Width-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
(Event.xbutton.x < Width-BAR_WIDTH))
{
target_x_offset += (Width-BAR_WIDTH-PAD_WIDTH2);
if(target_x_offset+Width-BAR_WIDTH -PAD_WIDTH3 > target_width)
target_x_offset = target_width - Width+BAR_WIDTH+PAD_WIDTH3;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
motion = NONE;
exposed = 2;
}
else if((motion == TOP)&&
(Event.xbutton.y<SCROLL_BAR_WIDTH+PAD_WIDTH3)&&
(Event.xbutton.x > Width-BAR_WIDTH))
{
target_y_offset -= (Height-BAR_WIDTH-PAD_WIDTH2);
if(target_y_offset < 0)
target_y_offset = 0;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
motion = NONE;
exposed = 2;
}
else if((motion == BOTTOM)&&
(Event.xbutton.y > Height-BAR_WIDTH-SCROLL_BAR_WIDTH-2) &&
(Event.xbutton.y < Height-BAR_WIDTH)&&
(Event.xbutton.x > Width-BAR_WIDTH))
{
target_y_offset += (Height-BAR_WIDTH-PAD_WIDTH2);
if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 > target_height)
target_y_offset = target_height - Height+BAR_WIDTH+PAD_WIDTH3;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
motion = NONE;
exposed = 2;
}
if(motion == VERTICAL)
{
target_y_offset=(Event.xbutton.y-PAD_WIDTH3-SCROLL_BAR_WIDTH)*target_height/
(Height-BAR_WIDTH-PAD_WIDTH3 - 2*SCROLL_BAR_WIDTH);
if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 > target_height)
target_y_offset = target_height - Height+BAR_WIDTH+PAD_WIDTH3;
if(target_y_offset < 0)
target_y_offset = 0;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
}
if(motion == HORIZONTAL)
{
target_x_offset=(Event.xbutton.x -PAD_WIDTH3-SCROLL_BAR_WIDTH)* target_width/
(Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH);
if(target_x_offset < 0)
target_x_offset = 0;
if(target_x_offset + Width - BAR_WIDTH -PAD_WIDTH3> target_width)
target_x_offset = target_width - Width + BAR_WIDTH+PAD_WIDTH3;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
}
RedrawWindow(target);
motion = NONE;
break;
case MotionNotify:
if((motion == LEFT)&&((Event.xmotion.y < Height-BAR_WIDTH) ||
(Event.xmotion.x > SCROLL_BAR_WIDTH+PAD_WIDTH3)))
{
motion = NONE;
exposed = 2;
}
else if((motion == RIGHT)&&((Event.xmotion.y < Height-BAR_WIDTH) ||
(Event.xmotion.x < Width-BAR_WIDTH-SCROLL_BAR_WIDTH-2) ||
(Event.xmotion.x > Width-BAR_WIDTH)))
{
motion = NONE;
exposed = 2;
}
else if((motion == TOP)&&
((Event.xmotion.y>SCROLL_BAR_WIDTH+PAD_WIDTH3)||
(Event.xmotion.x < Width-BAR_WIDTH)))
{
motion = NONE;
exposed = 2;
}
else if((motion == BOTTOM)&&
((Event.xmotion.y < Height-BAR_WIDTH-SCROLL_BAR_WIDTH-2) ||
(Event.xmotion.y > Height-BAR_WIDTH)||
(Event.xmotion.x < Width-BAR_WIDTH)))
{
motion = NONE;
exposed = 2;
}
if(motion == VERTICAL)
{
target_y_offset=(Event.xmotion.y-PAD_WIDTH3-SCROLL_BAR_WIDTH)*
target_height/
(Height-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH);
if(target_y_offset+Height-BAR_WIDTH -PAD_WIDTH3 > target_height)
target_y_offset = target_height - Height+BAR_WIDTH+PAD_WIDTH3;
if(target_y_offset < 0)
target_y_offset = 0;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
}
if(motion == HORIZONTAL)
{
target_x_offset=(Event.xmotion.x -PAD_WIDTH3-SCROLL_BAR_WIDTH)*
target_width/
(Width-BAR_WIDTH-PAD_WIDTH3-2*SCROLL_BAR_WIDTH);
if(target_x_offset < 0)
target_x_offset = 0;
if(target_x_offset + Width - BAR_WIDTH -PAD_WIDTH3> target_width)
target_x_offset = target_width - Width + BAR_WIDTH+PAD_WIDTH3;
XMoveWindow(dpy,target,-target_x_offset, -target_y_offset);
}
if((motion == QUIT)&&
((Event.xbutton.y < Height- BAR_WIDTH )||
(Event.xbutton.x < Width- BAR_WIDTH)))
{
motion = NONE;
exposed = 2;
}
RedrawWindow(target);
break;
case ClientMessage:
if ((Event.xclient.format==32) &&
(Event.xclient.data.l[0]==wm_del_win))
{
DeadPipe(1);
}
break;
case PropertyNotify:
if(Event.xproperty.atom == XA_WM_NAME)
{
if(XFetchName(dpy, target, &temp)==0)
temp = NULL;
change_window_name(temp);
}
else if (Event.xproperty.atom == XA_WM_ICON_NAME)
{
if (XGetWindowProperty (dpy,
target, Event.xproperty.atom, 0,
MAX_ICON_NAME_LEN, False, XA_STRING,
&actual,&actual_format, &nitems,
&bytesafter, (unsigned char **) &prop)
== Success && (prop != NULL))
change_icon_name(prop);
}
else if(Event.xproperty.atom == XA_WM_HINTS)
{
XWMHints *wmhints;
wmhints = XGetWMHints(dpy,target);
XSetWMHints(dpy,main_win, wmhints);
XFree(wmhints);
}
else if(Event.xproperty.atom == XA_WM_NORMAL_HINTS)
{
/* don't do Normal Hints. They alter the size of the window */
}
else if (Event.xproperty.atom == _XA_WM_COLORMAP_WINDOWS)
{
}
break;
case DestroyNotify:
DeadPipe(1);
break;
case UnmapNotify:
break;
case MapNotify:
XMapWindow(dpy,main_win);
break;
case FocusIn:
XSetInputFocus(dpy,target,RevertToParent,CurrentTime);
break;
case ColormapNotify:
{
XWindowAttributes xwa;
if(XGetWindowAttributes(dpy,target, &xwa) != 0)
{
XSetWindowColormap(dpy,main_win,xwa.colormap);
}
}
break;
default:
break;
}
}
return;
}
static bool gfx_ctx_set_video_mode(
unsigned width, unsigned height,
bool fullscreen)
{
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
bool windowed_full = g_settings.video.windowed_fullscreen;
bool true_full = false;
int x_off = 0;
int y_off = 0;
EGLint vid;
if (!eglGetConfigAttrib(g_egl_dpy, g_config, EGL_NATIVE_VISUAL_ID, &vid))
goto error;
temp.visualid = vid;
EGLint num_visuals;
vi = XGetVisualInfo(g_dpy, VisualIDMask, &temp, &num_visuals);
if (!vi)
goto error;
swa.colormap = g_cmap = XCreateColormap(g_dpy, RootWindow(g_dpy, vi->screen),
vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask;
swa.override_redirect = fullscreen ? True : False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_dpy, width, height, &g_desktop_mode))
{
g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[X/EGL]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
if (g_settings.video.monitor_index)
g_screen = g_settings.video.monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (x11_get_xinerama_coord(g_dpy, g_screen, &x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[X/EGL]: Using Xinerama on screen #%u.\n", g_screen);
else
RARCH_LOG("[X/EGL]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[X/EGL]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_win = XCreateWindow(g_dpy, RootWindow(g_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_dpy, g_win, 0);
// GLES 2.0. Don't use for any other API.
static const EGLint egl_ctx_gles_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE,
};
g_egl_ctx = eglCreateContext(g_egl_dpy, g_config, EGL_NO_CONTEXT,
(g_api == GFX_CTX_OPENGL_ES_API) ? egl_ctx_gles_attribs : NULL);
if (!g_egl_ctx)
goto error;
g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, (EGLNativeWindowType)g_win, NULL);
if (!g_egl_surf)
goto error;
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
goto error;
gfx_ctx_update_window_title(true);
x11_set_window_attr(g_dpy, g_win);
if (fullscreen)
x11_hide_mouse(g_dpy, g_win);
if (true_full)
{
RARCH_LOG("[GLX]: Using true fullscreen.\n");
XMapRaised(g_dpy, g_win);
}
else if (fullscreen) // We attempted true fullscreen, but failed. Attempt using windowed fullscreen.
{
XMapRaised(g_dpy, g_win);
RARCH_LOG("[X/EGL]: Using windowed fullscreen.\n");
// We have to move the window to the screen we want to go fullscreen on first.
// x_off and y_off usually get ignored in XCreateWindow().
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
x11_windowed_fullscreen(g_dpy, g_win);
}
else
{
XMapWindow(g_dpy, g_win);
// If we want to map the window on a different screen, we'll have to do it by force.
// Otherwise, we should try to let the window manager sort it out.
// x_off and y_off usually get ignored in XCreateWindow().
if (g_screen)
x11_move_window(g_dpy, g_win, x_off, y_off, width, height);
}
XEvent event;
XIfEvent(g_dpy, &event, egl_wait_notify, NULL);
XSetInputFocus(g_dpy, g_win, RevertToNone, CurrentTime);
g_quit_atom = XInternAtom(g_dpy, "WM_DELETE_WINDOW", False);
if (g_quit_atom)
XSetWMProtocols(g_dpy, g_win, &g_quit_atom, 1);
gfx_ctx_swap_interval(g_interval);
XFree(vi);
g_has_focus = true;
g_inited = true;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)g_dpy;
driver.video_window = (uintptr_t)g_win;
g_true_full = true_full;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_destroy();
return false;
}
/*****************************************************************************
* Manage: handle omapfb events
*****************************************************************************
* This function should be called regularly by video output thread.
*****************************************************************************/
static int Manage( vout_thread_t *p_vout )
{
XEvent xevent;
while( XPending( p_vout->p_sys->p_display ) )
{
XNextEvent( p_vout->p_sys->p_display, &xevent );
if( xevent.type == ButtonPress &&
((XButtonEvent *)&xevent)->button == Button1 )
{
/* detect double-clicks */
if( ( ((XButtonEvent *)&xevent)->time -
p_vout->p_sys->i_time_button_last_pressed ) < 300 )
{
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
}
p_vout->p_sys->i_time_button_last_pressed =
((XButtonEvent *)&xevent)->time;
}
else if( xevent.type == KeyPress )
{
KeySym x_key_symbol;
vlc_value_t val;
x_key_symbol = XKeycodeToKeysym( p_vout->p_sys->p_display,
xevent.xkey.keycode, 0 );
switch( x_key_symbol )
{
case XK_Return:
val.i_int = ACTIONID_PLAY_PAUSE; break;
case XK_Escape:
val.i_int = ACTIONID_QUIT; break;
case XK_Down:
val.i_int = ACTIONID_JUMP_BACKWARD_MEDIUM; break;
case XK_Up:
val.i_int = ACTIONID_JUMP_FORWARD_MEDIUM; break;
case XK_Right:
val.i_int = ACTIONID_JUMP_FORWARD_SHORT; break;
case XK_Left:
val.i_int = ACTIONID_JUMP_BACKWARD_SHORT; break;
case XK_F6:
val.i_int = ACTIONID_TOGGLE_FULLSCREEN; break;
case XK_F7:
val.i_int = ACTIONID_VOL_UP; break;
case XK_F8:
val.i_int = ACTIONID_VOL_DOWN; break;
}
var_SetInteger( p_vout->p_libvlc, "key-action", val.i_int );
}
else if( ( xevent.type == VisibilityNotify &&
xevent.xvisibility.state == VisibilityUnobscured ) ||
xevent.type == FocusIn )
{
p_vout->p_sys->b_video_enabled = true;
p_vout->p_sys->p_output_picture->p->p_pixels =
p_vout->p_sys->p_center;
XSetInputFocus( p_vout->p_sys->p_display, p_vout->p_sys->window,
RevertToParent, CurrentTime );
}
else if( ( xevent.type == VisibilityNotify &&
xevent.xvisibility.state != VisibilityUnobscured ) ||
xevent.type == FocusOut || xevent.type == UnmapNotify )
{
UpdateScreen( p_vout, 0, 0,
p_vout->p_sys->fb_vinfo.xres,
p_vout->p_sys->fb_vinfo.yres,
p_vout->p_sys->fb_vinfo.xres,
p_vout->p_sys->fb_vinfo.yres,
OMAPFB_COLOR_RGB565 );
p_vout->p_sys->b_video_enabled = false;
p_vout->p_sys->p_output_picture->p->p_pixels =
p_vout->p_sys->p_null;
}
}
if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
{
/* Update the object variable and trigger callback */
var_SetBool( p_vout, "fullscreen", !p_vout->b_fullscreen );
if( p_vout->p_sys->b_embed )
ToggleFullScreen( p_vout );
p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
}
if( p_vout->i_changes & VOUT_SIZE_CHANGE )
{
FreePicture( p_vout, p_vout->p_sys->p_output_picture );
if( Init( p_vout ) )
{
msg_Err( p_vout, "cannot reinit framebuffer screen" );
return VLC_EGENERIC;
}
}
#ifdef HAVE_OSSO
if ( p_vout->p_sys->p_octx != NULL ) {
if ( p_vout->p_sys->i_backlight_on_counter == i_backlight_on_interval ) {
if ( osso_display_blanking_pause( p_vout->p_sys->p_octx ) != OSSO_OK ) {
msg_Err( p_vout, "Could not disable backlight blanking" );
} else {
msg_Dbg( p_vout, "Backlight blanking disabled" );
}
p_vout->p_sys->i_backlight_on_counter = 0;
} else {
p_vout->p_sys->i_backlight_on_counter ++;
}
}
#endif
return VLC_SUCCESS;
}
static void
draw_it (LoginWidget w)
{
#ifdef XPM
int i,in_frame_x,in_login_y,in_pass_y,in_width,in_height;
int gr_line_x, gr_line_y, gr_line_w;
#endif /* XPM */
EraseCursor (w);
#ifdef XPM
if( (w->login.outframewidth) < 1 )
w->login.outframewidth = 1;
for(i=1;i<=(w->login.outframewidth);i++)
{
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
i-1,i-1,w->core.width-i,i-1);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
i-1,i-1,i-1,w->core.height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
w->core.width-i,i-1,w->core.width-i,w->core.height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
i-1,w->core.height-i,w->core.width-i,w->core.height-i);
}
/* make separator line */
gr_line_x = w->login.outframewidth + w->login.logoPadding;
gr_line_y = GREET_Y(w) + GREET_Y_INC(w);
gr_line_w = w->core.width - 2*(w->login.outframewidth) -
(w->login.logoWidth + 3*(w->login.logoPadding));
for(i=1;i<=(w->login.sepwidth);i++)
{
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
gr_line_x, gr_line_y + i-1,
gr_line_x+gr_line_w, gr_line_y + i-1);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
gr_line_x, gr_line_y + 2*(w->login.inframeswidth) -i,
gr_line_x+gr_line_w, gr_line_y + 2*(w->login.inframeswidth) -i);
}
in_frame_x = LOGIN_TEXT_X(w) - w->login.inframeswidth - 3;
in_login_y = LOGIN_Y(w) - w->login.inframeswidth - 1 - TEXT_Y_INC(w);
in_pass_y = PASS_Y(w) - w->login.inframeswidth - 1 - TEXT_Y_INC(w);
in_width = LOGIN_W(w) - PROMPT_W(w) -
(w->login.logoWidth + 2*(w->login.logoPadding));
in_height = LOGIN_H(w) + w->login.inframeswidth + 2;
for(i=1;i<=(w->login.inframeswidth);i++)
{
/* Make top/left sides */
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
in_frame_x + i-1, in_login_y + i-1,
in_frame_x + in_width-i, in_login_y + i-1);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
in_frame_x + i-1, in_login_y + i-1,
in_frame_x + i-1, in_login_y + in_height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
in_frame_x + in_width-i, in_login_y + i-1,
in_frame_x + in_width-i, in_login_y + in_height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
in_frame_x + i-1, in_login_y + in_height-i,
in_frame_x + in_width-i, in_login_y + in_height-i);
/* Make bottom/right sides */
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
in_frame_x + i-1, in_pass_y + i-1,
in_frame_x + in_width-i, in_pass_y + i-1);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.shdGC,
in_frame_x + i-1, in_pass_y + i-1,
in_frame_x + i-1, in_pass_y + in_height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
in_frame_x + in_width-i, in_pass_y + i-1,
in_frame_x + in_width-i, in_pass_y + in_height-i);
XDrawLine(XtDisplay (w), XtWindow (w), w->login.hiGC,
in_frame_x + i-1, in_pass_y + in_height-i,
in_frame_x + in_width-i, in_pass_y + in_height-i);
}
#endif /* XPM */
if (GREETING(w)[0])
XDrawString (XtDisplay (w), XtWindow (w), w->login.greetGC,
#ifndef XPM
GREET_X(w), GREET_Y(w),
#else
GREET_X(w) -
((w->login.logoWidth/2) + w->login.logoPadding),
GREET_Y(w),
#endif /* XPM */
GREETING(w), strlen (GREETING(w)));
XDrawString (XtDisplay (w), XtWindow (w), w->login.promptGC,
LOGIN_X(w), LOGIN_Y(w),
w->login.namePrompt, strlen (w->login.namePrompt));
XDrawString (XtDisplay (w), XtWindow (w), w->login.promptGC,
PASS_X(w), PASS_Y(w),
w->login.passwdPrompt, strlen (w->login.passwdPrompt));
RedrawFail (w);
DrawName (w, 0);
XorCursor (w);
/*
* The GrabKeyboard here is needed only because of
* a bug in the R3 server -- the keyboard is grabbed on
* the root window, and the server won't dispatch events
* to the focus window unless the focus window is a ancestor
* of the grab window. Bug in server already found and fixed,
* compatibility until at least R4.
*/
if (XGrabKeyboard (XtDisplay (w), XtWindow (w), False, GrabModeAsync,
GrabModeAsync, CurrentTime) != GrabSuccess)
{
XSetInputFocus (XtDisplay (w), XtWindow (w),
RevertToPointerRoot, CurrentTime);
}
}
static void edit_box_event(void *cookie, const XEvent *ev) {
EDIT_BOX *sb = cookie;
int inew;
int nn = sb->n;
int done = 0, i;
char ch;
int ihot = sb->hot;
Window wt;
Window w = sb->win[ihot]; /* active window */
char *s = sb->value[ihot];
switch (ev->type) {
case ConfigureNotify:
case Expose:
case MapNotify:
expose_ebox(sb, ev->xany.window);
break;
case ButtonRelease:
if (ev->xbutton.window == sb->ok) {
if (!sb->commit_func(sb->cookie, (char *)sb->value, sb->n)) {
edit_box_destroy(sb);
return;
}
} else if (ev->xbutton.window == sb->cancel) {
edit_box_destroy(sb);
return;
} else if (ev->xbutton.window == sb->reset) {
reset_ebox(sb);
}
break;
case ButtonPress:
for (i = 0; i < nn; i++) {
if (ev->xbutton.window == sb->win[i]) {
XSetInputFocus(display, sb->win[i], RevertToParent, CurrentTime);
if (i != sb->hot)
enew_editable(sb, i, &done, &w);
break;
}
}
break;
case EnterNotify:
wt = ev->xcrossing.window;
if (wt == sb->ok || wt == sb->cancel || wt == sb->reset)
XSetWindowBorderWidth(display, wt, 2);
break;
case LeaveNotify:
wt = ev->xcrossing.window;
if (wt == sb->ok || wt == sb->cancel || wt == sb->reset)
XSetWindowBorderWidth(display, wt, 1);
break;
case KeyPress:
ch = get_key_press(ev);
edit_window(w, &sb->pos, s, &sb->col, &done, ch);
if (done != 0) {
if (done == 2) {
edit_box_destroy(sb);
return;
}
inew = (sb->hot + 1) % nn;
enew_editable(sb, inew, &done, &w);
}
break;
}
}
struct menu *
menu_filter(struct screen_ctx *sc, struct menu_q *menuq, char *prompt,
char *initial, int dummy,
void (*match)(struct menu_q *, struct menu_q *, char *),
void (*print)(struct menu *, int))
{
struct menu_ctx mc;
struct menu_q resultq;
struct menu *mi = NULL;
XEvent e;
Window focuswin;
int evmask, focusrevert;
int xsave, ysave, xcur, ycur;
TAILQ_INIT(&resultq);
bzero(&mc, sizeof(mc));
xu_ptr_getpos(sc->rootwin, &mc.x, &mc.y);
xsave = mc.x;
ysave = mc.y;
if (prompt == NULL) {
evmask = MENUMASK;
mc.promptstr[0] = '\0';
mc.list = 1;
} else {
evmask = MENUMASK | KEYMASK; /* only accept keys if prompt */
(void)snprintf(mc.promptstr, sizeof(mc.promptstr), "%s%s",
prompt, PROMPT_SCHAR);
(void)snprintf(mc.dispstr, sizeof(mc.dispstr), "%s%s%s",
mc.promptstr, mc.searchstr, PROMPT_ECHAR);
mc.width = font_width(sc, mc.dispstr, strlen(mc.dispstr));
mc.hasprompt = 1;
}
if (initial != NULL)
(void)strlcpy(mc.searchstr, initial, sizeof(mc.searchstr));
else
mc.searchstr[0] = '\0';
mc.match = match;
mc.print = print;
mc.entry = mc.prev = -1;
XMoveResizeWindow(X_Dpy, sc->menuwin, mc.x, mc.y, mc.width,
font_height(sc));
XSelectInput(X_Dpy, sc->menuwin, evmask);
XMapRaised(X_Dpy, sc->menuwin);
if (xu_ptr_grab(sc->menuwin, MENUGRABMASK, Cursor_question) < 0) {
XUnmapWindow(X_Dpy, sc->menuwin);
return (NULL);
}
XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
XSetInputFocus(X_Dpy, sc->menuwin, RevertToPointerRoot, CurrentTime);
/* make sure keybindings don't remove keys from the menu stream */
XGrabKeyboard(X_Dpy, sc->menuwin, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
for (;;) {
mc.changed = 0;
XWindowEvent(X_Dpy, sc->menuwin, evmask, &e);
switch (e.type) {
case KeyPress:
if ((mi = menu_handle_key(&e, &mc, menuq, &resultq))
!= NULL)
goto out;
/* FALLTHROUGH */
case Expose:
menu_draw(sc, &mc, menuq, &resultq);
break;
case MotionNotify:
menu_handle_move(&e, &mc, sc);
break;
case ButtonRelease:
if ((mi = menu_handle_release(&e, &mc, sc, &resultq))
!= NULL)
goto out;
break;
default:
break;
}
}
out:
if (dummy == 0 && mi->dummy) { /* no mouse based match */
xfree(mi);
mi = NULL;
}
XSetInputFocus(X_Dpy, focuswin, focusrevert, CurrentTime);
/* restore if user didn't move */
xu_ptr_getpos(sc->rootwin, &xcur, &ycur);
if (xcur == mc.x && ycur == mc.y)
xu_ptr_setpos(sc->rootwin, xsave, ysave);
xu_ptr_ungrab();
XUnmapWindow(X_Dpy, sc->menuwin);
XUngrabKeyboard(X_Dpy, CurrentTime);
return (mi);
}
void
handle_press (int x, int y, int button)
{
task *tk;
#ifdef PAGER
if (y > 2 && y < WINHEIGHT - 2)
switch_desk ((x - GRILL_WIDTH) / PAGER_BUTTON_WIDTH);
#endif
/* clicked left grill */
if (x < 6)
{
if (tb.hidden)
tb.hidden = 0;
else
tb.at_top = !tb.at_top;
move_taskbar ();
return;
}
/* clicked right grill */
if (x + TEXTPAD > WINWIDTH)
{
tb.hidden = !tb.hidden;
move_taskbar ();
return;
}
tk = tb.task_list;
while (tk)
{
if (x > tk->pos_x && x < tk->pos_x + tk->width)
{
if (button == 3) /* right-click */
{
toggle_shade (tk->win);
return;
}
if (tk->iconified)
{
tk->iconified = 0;
tk->focused = 1;
XMapWindow (dd, tk->win);
} else
{
if (tk->focused)
{
tk->iconified = 1;
tk->focused = 0;
XIconifyWindow (dd, tk->win, scr_screen);
} else
{
tk->focused = 1;
XRaiseWindow (dd, tk->win);
XSetInputFocus (dd, tk->win, RevertToNone, CurrentTime);
}
}
gui_sync ();
gui_draw_task (tk);
} else
{
if (button == 1 && tk->focused)
{
tk->focused = 0;
gui_draw_task (tk);
}
}
tk = tk->next;
}
}
/*
* handle X11 events
* here we handle key, mouse, repaint and window sizing events
*/
static void X11_HandleEvents(GF_VideoOutput *vout)
{
GF_Event evt;
Window the_window;
XComposeStatus state;
X11VID();
unsigned char keybuf[32];
XEvent xevent;
the_window = xWindow->fullscreen ? xWindow->full_wnd : xWindow->wnd;
XSync(xWindow->display, False);
while (X11_Pending(xWindow->display)) {
XNextEvent(xWindow->display, &xevent);
if (xevent.xany.window!=the_window) continue;
switch (xevent.type) {
/*
* X11 window resized event
* must inform GPAC to resize os_handle wnd
*/
case ConfigureNotify:
if ((unsigned int) xevent.xconfigure.width != xWindow->w_width
|| (unsigned int) xevent.xconfigure.height != xWindow->w_height)
{
evt.type = GF_EVENT_SIZE;
xWindow->w_width = evt.size.width = xevent.xconfigure.width;
xWindow->w_height = evt.size.height = xevent.xconfigure.height;
vout->on_event(vout->evt_cbk_hdl, &evt);
}
break;
/*
* Windows need repaint
*/
case Expose:
if (xevent.xexpose.count > 0) break;
evt.type = GF_EVENT_REFRESH;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:
if ( (xevent.xclient.format == 32) && (xevent.xclient.data.l[0] == xWindow->WM_DELETE_WINDOW) ) {
evt.type = GF_EVENT_QUIT;
vout->on_event(vout->evt_cbk_hdl, &evt);
}
break;
case KeyPress:
case KeyRelease:
x11_translate_key(XKeycodeToKeysym (xWindow->display, xevent.xkey.keycode, 0), &evt.key);
evt.type = (xevent.type ==KeyPress) ? GF_EVENT_KEYDOWN : GF_EVENT_KEYUP;
vout->on_event (vout->evt_cbk_hdl, &evt);
if (xevent.type ==KeyPress) {
XLookupString (&xevent.xkey, (char *) keybuf, sizeof(keybuf), NULL, &state);
if (keybuf[0]) {
evt.character.unicode_char = keybuf[0];
evt.type = GF_EVENT_TEXTINPUT;
vout->on_event (vout->evt_cbk_hdl, &evt);
}
}
break;
case ButtonPress:
if (!xWindow->fullscreen && !xWindow->has_focus) {
xWindow->has_focus = 1;
XSetInputFocus(xWindow->display, xWindow->wnd, RevertToParent, CurrentTime);
}
case ButtonRelease:
// last_mouse_move = xevent.xbutton.time;
evt.mouse.x = xevent.xbutton.x;
evt.mouse.y = xevent.xbutton.y;
evt.type = (xevent.type == ButtonRelease) ? GF_EVENT_MOUSEUP : GF_EVENT_MOUSEDOWN;
switch (xevent.xbutton.button) {
case Button1:
evt.mouse.button = GF_MOUSE_LEFT;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button2:
evt.mouse.button = GF_MOUSE_MIDDLE;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button3:
evt.mouse.button = GF_MOUSE_RIGHT;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case Button4:
evt.type = GF_EVENT_MOUSEWHEEL;
evt.mouse.wheel_pos = FIX_ONE;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
case Button5:
evt.type = GF_EVENT_MOUSEWHEEL;
evt.mouse.wheel_pos = -FIX_ONE;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
}
if (!xWindow->fullscreen && (xevent.type==ButtonPress) )
XSetInputFocus(xWindow->display, xWindow->wnd, RevertToNone, CurrentTime);
break;
case MotionNotify:
evt.type = GF_EVENT_MOUSEMOVE;
evt.mouse.x = xevent.xmotion.x;
evt.mouse.y = xevent.xmotion.y;
vout->on_event (vout->evt_cbk_hdl, &evt);
break;
case PropertyNotify:
break;
case MapNotify:
break;
case CirculateNotify:
break;
case UnmapNotify:
break;
case ReparentNotify:
break;
case FocusOut:
if (!xWindow->fullscreen) xWindow->has_focus = 0;
break;
case FocusIn:
if (!xWindow->fullscreen) xWindow->has_focus = 1;
break;
case DestroyNotify:
evt.type = GF_EVENT_QUIT;
vout->on_event(vout->evt_cbk_hdl, &evt);
break;
default:
break;
}
}
}
static void HandleEvents( void )
{
XEvent event;
qboolean dowarp = qfalse, was_focused = focus;
int mwx = x11display.win_width / 2;
int mwy = x11display.win_height / 2;
char *p;
int key = 0;
int time = 0;
assert( x11display.dpy && x11display.win );
#ifdef WSW_EVDEV
if( mouse_active && m_evdev_num )
{
evdev_read();
}
else
#endif
if( mouse_active && !dgamouse )
{
int root_x, root_y, win_x, win_y;
unsigned int mask;
Window root, child;
if( XQueryPointer( x11display.dpy, x11display.win, &root, &child,
&root_x, &root_y, &win_x, &win_y, &mask ) )
{
mx += ( (int)win_x - mwx );
my += ( (int)win_y - mwy );
mwx = win_x;
mwy = win_y;
if( mx || my )
dowarp = qtrue;
if( ignore_one )
{
mx = my = 0;
ignore_one = qfalse;
}
}
}
while( XPending( x11display.dpy ) )
{
XNextEvent( x11display.dpy, &event );
switch( event.type )
{
case KeyPress:
time = Sys_XTimeToSysTime(event.xkey.time);
p = XLateKey( &event.xkey, &key );
if( key )
Key_Event( key, qtrue, time );
while ( p && *p )
{
qwchar wc = Q_GrabWCharFromUtf8String( (const char **)&p );
Key_CharEvent( key, wc );
}
break;
case KeyRelease:
if( repeated_press( &event ) )
break; // don't send release events when repeating
time = Sys_XTimeToSysTime(event.xkey.time);
XLateKey( &event.xkey, &key );
Key_Event( key, event.type == KeyPress, time );
break;
case MotionNotify:
#ifdef WSW_EVDEV
if( mouse_active && dgamouse && !m_evdev_num )
#else
if( mouse_active && dgamouse )
#endif
{
mx += event.xmotion.x_root;
my += event.xmotion.y_root;
if( ignore_one )
{
mx = my = 0;
ignore_one = qfalse;
}
}
break;
case ButtonPress:
if( ( cls.key_dest == key_console ) && !in_grabinconsole->integer )
break;
#ifdef WSW_EVDEV
if( m_evdev_num )
break;
#endif
time = Sys_XTimeToSysTime(event.xkey.time);
if( event.xbutton.button == 1 ) Key_MouseEvent( K_MOUSE1, 1, time );
else if( event.xbutton.button == 2 ) Key_MouseEvent( K_MOUSE3, 1, time );
else if( event.xbutton.button == 3 ) Key_MouseEvent( K_MOUSE2, 1, time );
else if( event.xbutton.button == 4 ) Key_Event( K_MWHEELUP, 1, time );
else if( event.xbutton.button == 5 ) Key_Event( K_MWHEELDOWN, 1, time );
else if( event.xbutton.button >= 6 && event.xbutton.button <= 10 ) Key_MouseEvent( K_MOUSE4+event.xbutton.button-6, 1, time );
break;
case ButtonRelease:
if( ( cls.key_dest == key_console ) && !in_grabinconsole->integer )
break;
#ifdef WSW_EVDEV
if( m_evdev_num )
break;
#endif
time = Sys_XTimeToSysTime(event.xkey.time);
if( event.xbutton.button == 1 ) Key_MouseEvent( K_MOUSE1, 0, time );
else if( event.xbutton.button == 2 ) Key_MouseEvent( K_MOUSE3, 0, time );
else if( event.xbutton.button == 3 ) Key_MouseEvent( K_MOUSE2, 0, time );
else if( event.xbutton.button == 4 ) Key_Event( K_MWHEELUP, 0, time );
else if( event.xbutton.button == 5 ) Key_Event( K_MWHEELDOWN, 0, time );
else if( event.xbutton.button >= 6 && event.xbutton.button <= 10 ) Key_MouseEvent( K_MOUSE4+event.xbutton.button-6, 0, time );
break;
case FocusIn:
if( x11display.ic )
XSetICFocus(x11display.ic);
if( !focus )
{
focus = qtrue;
}
break;
case FocusOut:
if( x11display.ic )
XUnsetICFocus(x11display.ic);
if( focus )
{
Key_ClearStates();
focus = qfalse;
}
break;
case ClientMessage:
if( event.xclient.data.l[0] == x11display.wmDeleteWindow )
Cbuf_ExecuteText( EXEC_NOW, "quit" );
break;
case MapNotify:
mapped = qtrue;
if( x11display.modeset )
{
if ( x11display.dpy && x11display.win )
{
XSetInputFocus( x11display.dpy, x11display.win, RevertToPointerRoot, CurrentTime );
x11display.modeset = qfalse;
}
}
if( input_active )
{
uninstall_grabs();
install_grabs();
}
break;
case ConfigureNotify:
VID_AppActivate( qtrue, qfalse );
break;
case PropertyNotify:
if( event.xproperty.window == x11display.win )
{
if ( event.xproperty.atom == x11display.wmState )
{
qboolean was_minimized = minimized;
_X11_CheckWMSTATE();
if( minimized != was_minimized )
{
// FIXME: find a better place for this?..
CL_SoundModule_Activate( !minimized );
}
}
}
break;
}
}
if( dowarp )
{
XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0,
x11display.win_width/2, x11display.win_height/2 );
}
// set fullscreen or windowed mode upon focus in/out events if:
// a) lost focus in fullscreen -> windowed
// b) received focus -> fullscreen if a)
if( ( focus != was_focused ) )
{
if( x11display.features.wmStateFullscreen )
{
if( !focus && Cvar_Value( "vid_fullscreen" ) )
{
go_fullscreen_on_focus = qtrue;
Cbuf_ExecuteText( EXEC_APPEND, "vid_fullscreen 0\n" );
}
else if( focus && go_fullscreen_on_focus )
{
go_fullscreen_on_focus = qfalse;
Cbuf_ExecuteText( EXEC_APPEND, "vid_fullscreen 1\n" );
}
}
}
}
int main(int argc, char *argv[]) {
struct sigaction act;
int argn = 1, ret;
{
const char *home = getenv("HOME");
if (home) {
char *conffile = xmalloc(strlen(home) + sizeof(CONFIG_FILE) + 2);
strcpy(conffile, home);
strcat(conffile, "/" CONFIG_FILE);
xconfig_parse_file(evilwm_options, conffile);
free(conffile);
}
}
ret = xconfig_parse_cli(evilwm_options, argc, argv, &argn);
if (ret == XCONFIG_MISSING_ARG) {
fprintf(stderr, "%s: missing argument to `%s'\n", argv[0], argv[argn]);
exit(1);
} else if (ret == XCONFIG_BAD_OPTION) {
if (0 == strcmp(argv[argn], "-h")
|| 0 == strcmp(argv[argn], "--help")) {
helptext();
exit(0);
#ifdef STDIO
} else if (0 == strcmp(argv[argn], "-V")
|| 0 == strcmp(argv[argn], "--version")) {
LOG_INFO("evilwm version " VERSION "\n");
exit(0);
#endif
} else {
helptext();
exit(1);
}
}
if (opt_grabmask1) grabmask1 = parse_modifiers(opt_grabmask1);
if (opt_grabmask2) grabmask2 = parse_modifiers(opt_grabmask2);
if (opt_altmask) altmask = parse_modifiers(opt_altmask);
wm_exit = 0;
act.sa_handler = handle_signal;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGTERM, &act, NULL);
sigaction(SIGINT, &act, NULL);
sigaction(SIGHUP, &act, NULL);
setup_display();
event_main_loop();
/* Quit Nicely */
while (clients_stacking_order)
remove_client(clients_stacking_order->data);
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
if (font) XFreeFont(dpy, font);
{
int i;
for (i = 0; i < num_screens; i++) {
ewmh_deinit_screen(&screens[i]);
XFreeGC(dpy, screens[i].invert_gc);
XInstallColormap(dpy, DefaultColormap(dpy, i));
}
}
free(screens);
XCloseDisplay(dpy);
return 0;
}
void X11Window::SetFocus()
{
XSetInputFocus(display, window, RevertToNone, CurrentTime);
}
// ######################################################################
void AutomateXWin::setFocus()
{
XSetInputFocus(itsDisplay, itsWindow, RevertToNone, CurrentTime);
}
static int config(uint32_t width, uint32_t height, uint32_t d_width,
uint32_t d_height, uint32_t flags, char *title,
uint32_t format)
{
// int screen;
// int interval, prefer_blank, allow_exp, nothing;
unsigned int fg, bg;
Colormap theCmap;
XSetWindowAttributes xswa;
unsigned long xswamask;
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
#endif
Flip_Flag = flags & VOFLAG_FLIPPING;
zoomFlag = flags & VOFLAG_SWSCALE;
old_vo_dwidth = -1;
old_vo_dheight = -1;
int_pause = 0;
if (!title)
title = "MPlayer X11 (XImage/Shm) render";
in_format = format;
srcW = width;
srcH = height;
XGetWindowAttributes(mDisplay, mRootWin, &attribs);
depth = attribs.depth;
if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
{
Visual *visual;
depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
}
if (!XMatchVisualInfo(mDisplay, mScreen, depth, DirectColor, &vinfo) ||
(WinID > 0
&& vinfo.visualid != XVisualIDFromVisual(attribs.visual)))
XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
/* set image size (which is indeed neither the input nor output size),
if zoom is on it will be changed during draw_slice anyway so we don't duplicate the aspect code here
*/
image_width = (width + 7) & (~7);
image_height = height;
#ifdef CONFIG_GUI
if (use_gui)
guiGetEvent(guiSetShVideo, 0); // the GUI will set up / resize the window
else
#endif
{
#ifdef CONFIG_XF86VM
if (vm)
{
vo_vm_switch();
}
#endif
bg = WhitePixel(mDisplay, mScreen);
fg = BlackPixel(mDisplay, mScreen);
theCmap = vo_x11_create_colormap(&vinfo);
xswa.background_pixel = 0;
xswa.border_pixel = 0;
xswa.colormap = theCmap;
xswamask = CWBackPixel | CWBorderPixel | CWColormap;
#ifdef CONFIG_XF86VM
if (vm)
{
xswa.override_redirect = True;
xswamask |= CWOverrideRedirect;
}
#endif
vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, vo_dwidth, vo_dheight,
flags, theCmap, "x11", title);
if (WinID > 0)
depth = vo_x11_update_geometry();
#ifdef CONFIG_XF86VM
if (vm)
{
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(mDisplay, vo_window, True, 0,
GrabModeAsync, GrabModeAsync,
vo_window, None, CurrentTime);
XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
}
#endif
}
if (myximage)
{
freeMyXImage();
sws_freeContext(swsContext);
}
getMyXImage();
while (fmte->mpfmt) {
int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
/* bits_per_pixel in X seems to be set to 16 for 15 bit formats
=> force depth to 16 so that only the color masks are used for the format check */
if (depth == 15)
depth = 16;
if (depth == myximage->bits_per_pixel &&
fmte->byte_order == myximage->byte_order &&
fmte->red_mask == myximage->red_mask &&
fmte->green_mask == myximage->green_mask &&
fmte->blue_mask == myximage->blue_mask)
break;
fmte++;
}
if (!fmte->mpfmt) {
mp_msg(MSGT_VO, MSGL_ERR,
"X server image format not supported, please contact the developers\n");
return -1;
}
out_format = fmte->mpfmt;
switch ((bpp = myximage->bits_per_pixel))
{
case 24:
draw_alpha_fnc = draw_alpha_24;
break;
case 32:
draw_alpha_fnc = draw_alpha_32;
break;
case 15:
case 16:
if (depth == 15)
draw_alpha_fnc = draw_alpha_15;
else
draw_alpha_fnc = draw_alpha_16;
break;
default:
draw_alpha_fnc = draw_alpha_null;
}
out_offset = 0;
// for these formats conversion is currently not support and
// we can easily "emulate" them.
if (out_format & 64 && (IMGFMT_IS_RGB(out_format) || IMGFMT_IS_BGR(out_format))) {
out_format &= ~64;
#ifdef WORDS_BIGENDIAN
out_offset = 1;
#else
out_offset = -1;
#endif
}
/* always allocate swsContext as size could change between frames */
swsContext =
sws_getContextFromCmdLine(width, height, in_format, width, height,
out_format);
if (!swsContext)
return -1;
dst_width = width;
//printf( "X11 bpp: %d color mask: R:%lX G:%lX B:%lX\n",bpp,myximage->red_mask,myximage->green_mask,myximage->blue_mask );
return 0;
}
void
CleanupScreen()
{
int i ;
if( Scr.Windows )
{
grab_server();
destroy_aswindow_list( &(Scr.Windows), True );
ungrab_server();
}
destroy_balloon_state(&TitlebarBalloons);
destroy_balloon_state(&MenuBalloons);
release_all_old_background( True );
DestroyManagementWindows();
CleanupColormaps();
if( Scr.RootCanvas )
destroy_ascanvas( &(Scr.RootCanvas) );
XSetInputFocus (dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
XSync (dpy, 0);
#ifdef HAVE_XINERAMA
if (Scr.xinerama_screens)
{
free (Scr.xinerama_screens);
Scr.xinerama_screens_num = 0;
Scr.xinerama_screens = NULL;
}
#endif /* XINERAMA */
for( i = 0 ; i < MAX_CURSORS; ++i )
if( Scr.standard_cursors[i] )
{
XFreeCursor( dpy, Scr.standard_cursors[i] );
Scr.standard_cursors[i] = None ;
}
InitLook(&Scr.Look, True);
InitFeel(&Scr.Feel, True);
/* free display strings; can't do this in main(), because some OS's
* don't copy the environment variables properly */
if( Scr.display_string )
{
free (Scr.display_string);
Scr.display_string = NULL ;
}
if( Scr.rdisplay_string )
{
free (Scr.rdisplay_string);
Scr.rdisplay_string = NULL ;
}
if( Scr.RootBackground )
{
if( Scr.RootBackground->pmap )
{
if( Scr.wmprops->root_pixmap == Scr.RootBackground->pmap )
{
set_xrootpmap_id (Scr.wmprops, None );
set_as_background(Scr.wmprops, None );
}
XFreePixmap( dpy, Scr.RootBackground->pmap );
ASSync(False);
LOCAL_DEBUG_OUT( "root pixmap with id %lX destroyed", Scr.RootBackground->pmap );
Scr.RootBackground->pmap = None ;
}
free( Scr.RootBackground );
}
LOCAL_DEBUG_OUT("destroying image manager : %p", Scr.image_manager);
destroy_image_manager( Scr.image_manager, False );
LOCAL_DEBUG_OUT("destroying font manager : %p", Scr.font_manager);
destroy_font_manager( Scr.font_manager, False );
LOCAL_DEBUG_OUT("destroying visual : %p", Scr.asv);
destroy_screen_gcs(ASDefaultScr);
destroy_asvisual( Scr.asv, False );
LOCAL_DEBUG_OUT("selecting input mask for Root window to 0 : %s","");
/* Must release SubstructureRedirectMask prior to releasing wm selection in
* destroy_wmprops() : */
XSelectInput( dpy, Scr.Root, 0 );
XUngrabPointer( dpy, CurrentTime );
XUngrabButton (dpy, AnyButton, AnyModifier, Scr.Root);
LOCAL_DEBUG_OUT("destroying wmprops : %p",Scr.wmprops);
/* this must be done at the very end !!!! */
destroy_wmprops( Scr.wmprops, False);
LOCAL_DEBUG_OUT("screen cleanup complete.%s","");
}
void video_output_qt::enter_fullscreen()
{
if (!_fullscreen) {
#ifdef Q_OS_MAC
_widget->stop_rendering();
#endif
// If the container is a window, we save its geometry here so that
// we can restore it later.
if (!_container_is_external)
_geom = _container_widget->geometry();
// If the container is not yet a window, but embedded in the main window,
// we need to make it a window now.
if (_container_is_external)
_container_widget->setWindowFlags(Qt::Window);
// Determine combined geometry of the chosen screens.
int screens = dispatch::parameters().fullscreen_screens();
int screen_count = 0;
QRect geom;
for (int i = 0; i < std::min(QApplication::desktop()->screenCount(), 16); i++) {
if (screens & (1 << i)) {
if (geom.isNull())
geom = QApplication::desktop()->screenGeometry(i);
else
geom = geom.united(QApplication::desktop()->screenGeometry(i));
screen_count++;
}
}
if (geom.isNull()) {
// Use default screen
geom = QApplication::desktop()->screenGeometry(-1);
}
Qt::WindowFlags new_window_flags =
_container_widget->windowFlags()
| Qt::FramelessWindowHint
| Qt::WindowStaysOnTopHint;
// In the dual and multi screen cases we need to bypass the window manager
// on X11 because Qt does not support _NET_WM_FULLSCREEN_MONITORS, and thus
// the window manager would always restrict the fullscreen window to one screen.
// Note: it may be better to set _NET_WM_FULLSCREEN_MONITORS ourselves, but that
// would also require the window manager to support this extension...
if (screen_count > 1)
new_window_flags |= Qt::X11BypassWindowManagerHint;
_container_widget->setWindowFlags(new_window_flags);
_container_widget->setWindowState(_container_widget->windowState() | Qt::WindowFullScreen);
_container_widget->setGeometry(geom);
_container_widget->setCursor(Qt::BlankCursor);
_container_widget->show();
_container_widget->raise();
_container_widget->activateWindow();
#ifdef Q_WS_X11
/* According to the Qt documentation, it should be sufficient to call activateWindow()
* to make a X11 window active when using Qt::X11BypassWindowManagerHint, but this
* does not work for me (Ubuntu 11.04 Gnome-2D desktop). This is a workaround. */
/* Note that using X11 functions directly means that we have to link with libX11
* explicitly; see configure.ac. */
/* In the hope that this crap is not necessary anymore with Qt5, we continue to test
* for Q_WS_X11, which is never defined with Qt5. */
if (new_window_flags & Qt::X11BypassWindowManagerHint) {
QApplication::syncX(); // just for safety; not sure if it is necessary
XSetInputFocus(QX11Info::display(), _container_widget->winId(), RevertToParent, CurrentTime);
XFlush(QX11Info::display());
}
#endif
_container_widget->grab_focus();
// Suspend the screensaver after going fullscreen, so that our window ID
// represents the fullscreen window. We need to have the same ID for resume.
if (dispatch::parameters().fullscreen_inhibit_screensaver()) {
suspend_screensaver();
_screensaver_inhibited = true;
}
_fullscreen = true;
#ifdef Q_OS_MAC
_widget->start_rendering();
#endif
}
}
static int config(uint32_t width, uint32_t height, uint32_t d_width,
uint32_t d_height, uint32_t flags, char *title,
uint32_t format)
{
// int screen;
// int interval, prefer_blank, allow_exp, nothing;
Colormap theCmap;
const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
#ifdef CONFIG_XF86VM
int vm = flags & VOFLAG_MODESWITCHING;
#endif
Flip_Flag = flags & VOFLAG_FLIPPING;
zoomFlag = flags & VOFLAG_SWSCALE;
old_vo_dwidth = -1;
old_vo_dheight = -1;
int_pause = 0;
if (!title)
title = "MPlayer X11 (XImage/Shm) render";
in_format = format;
srcW = width;
srcH = height;
XGetWindowAttributes(mDisplay, mRootWin, &attribs);
depth = attribs.depth;
if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
{
Visual *visual;
depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
}
if (!XMatchVisualInfo(mDisplay, mScreen, depth, DirectColor, &vinfo) ||
(WinID > 0
&& vinfo.visualid != XVisualIDFromVisual(attribs.visual)))
XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
/* set image size (which is indeed neither the input nor output size),
if zoom is on it will be changed during draw_slice anyway so we don't duplicate the aspect code here
*/
image_width = (width + 7) & (~7);
image_height = height;
{
#ifdef CONFIG_XF86VM
if (vm)
{
vo_vm_switch();
}
#endif
theCmap = vo_x11_create_colormap(&vinfo);
vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, vo_dwidth, vo_dheight,
flags, theCmap, "x11", title);
if (WinID > 0)
depth = vo_x11_update_geometry();
#ifdef CONFIG_XF86VM
if (vm)
{
/* Grab the mouse pointer in our window */
if (vo_grabpointer)
XGrabPointer(mDisplay, vo_window, True, 0,
GrabModeAsync, GrabModeAsync,
vo_window, None, CurrentTime);
XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
}
#endif
}
if (myximage)
{
freeMyXImage();
sws_freeContext(swsContext);
}
getMyXImage();
while (fmte->mpfmt) {
int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
/* bits_per_pixel in X seems to be set to 16 for 15 bit formats
=> force depth to 16 so that only the color masks are used for the format check */
if (depth == 15)
depth = 16;
if (depth == myximage->bits_per_pixel &&
fmte->byte_order == myximage->byte_order &&
fmte->red_mask == myximage->red_mask &&
fmte->green_mask == myximage->green_mask &&
fmte->blue_mask == myximage->blue_mask)
break;
fmte++;
}
if (!fmte->mpfmt) {
mp_msg(MSGT_VO, MSGL_ERR,
"X server image format not supported, please contact the developers\n");
return -1;
}
out_format = fmte->mpfmt;
draw_alpha_func = vo_get_draw_alpha(out_format);
bpp = myximage->bits_per_pixel;
out_offset = 0;
// We can easily "emulate" non-native RGB32 and BGR32
if (out_format == (IMGFMT_BGR32 | 128) || out_format == (IMGFMT_RGB32 | 128)) {
out_format &= ~128;
#if HAVE_BIGENDIAN
out_offset = 1;
#else
out_offset = -1;
#endif
}
/* always allocate swsContext as size could change between frames */
swsContext =
sws_getContextFromCmdLine(width, height, in_format, width, height,
out_format);
if (!swsContext)
return -1;
dst_width = width;
//printf( "X11 bpp: %d color mask: R:%lX G:%lX B:%lX\n",bpp,myximage->red_mask,myximage->green_mask,myximage->blue_mask );
return 0;
}
static void
event_clientmessageevent(XEvent *e)
{
XClientMessageEvent *ev = &e->xclient;
struct client *c;
struct _systray *sy;
int type = 0;
while(type < net_last && W->net_atom[type] != ev->message_type)
++type;
/*
* Systray message
* _NET_WM_SYSTRAY_TRAY_OPCODE
*/
if(ev->window == W->systray.win && type == net_system_tray_opcode)
{
if(ev->data.l[1] == XEMBED_EMBEDDED_NOTIFY)
{
systray_add(ev->data.l[2]);
systray_update();
}
else if(ev->data.l[1] == XEMBED_REQUEST_FOCUS)
{
if((sy = systray_find(ev->data.l[2])))
ewmh_send_message(sy->win, sy->win, "_XEMBED", XEMBED_FOCUS_IN,
XEMBED_FOCUS_CURRENT, 0, 0, 0);
}
}
else if(ev->window == W->root)
{
/* WMFS message */
if(ev->data.l[4])
{
/* Manage _WMFS_FUNCTION && _WMFS_CMD */
if(type == wmfs_function || type == wmfs_cmd)
{
Atom rt;
int d;
long unsigned int len, il;
unsigned char *ret = NULL, *ret_cmd = NULL;
void (*func)(Uicb);
if(XGetWindowProperty(EVDPY(e), W->root, W->net_atom[wmfs_function], 0, 65536,
False, W->net_atom[utf8_string], &rt, &d,
&len, &il, &ret) == Success
&& ret && ((func = uicb_name_func((char*)ret))))
{
if(XGetWindowProperty(EVDPY(e), W->root, W->net_atom[wmfs_cmd], 0, 65536,
False, W->net_atom[utf8_string], &rt, &d,
&len, &il, &ret_cmd) == Success
&& len && ret_cmd)
{
func((Uicb)ret_cmd);
XFree(ret_cmd);
}
else
func(NULL);
XFree(ret);
}
}
}
if(type == net_active_window)
if((sy = systray_find(ev->data.l[0])))
XSetInputFocus(W->dpy, sy->win, RevertToNone, CurrentTime);
}
switch(type)
{
/* _NET_WM_STATE */
case net_wm_state:
if((c = client_gb_win(ev->window)))
ewmh_manage_state(ev->data.l, c);
break;
/* _NET_CLOSE_WINDOW */
case net_close_window:
if((c = client_gb_win(ev->window)))
client_close(c);
break;
/* _NET_WM_DESKTOP */
case net_wm_desktop:
break;
}
}
void fgPlatformEnterGameMode( void )
{
/*
* Sync needed to avoid a real race, the Xserver must have really created
* the window before we can grab the pointer into it:
*/
XSync( fgDisplay.pDisplay.Display, False );
/*
* Grab the pointer to confine it into the window after the calls to
* XWrapPointer() which ensure that the pointer really enters the window.
*
* We also need to wait here until XGrabPointer() returns GrabSuccess,
* otherwise the new window is not viewable yet and if the next function
* (XSetInputFocus) is called with a not yet viewable window, it will exit
* the application which we have to aviod, so wait until it's viewable:
*/
while( GrabSuccess != XGrabPointer(
fgDisplay.pDisplay.Display, fgStructure.GameModeWindow->Window.Handle,
TRUE,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask
| PointerMotionMask,
GrabModeAsync, GrabModeAsync,
fgStructure.GameModeWindow->Window.Handle, None, CurrentTime) )
usleep( 100 );
/*
* Change input focus to the new window. This will exit the application
* if the new window is not viewable yet, see the XGrabPointer loop above.
*/
XSetInputFocus(
fgDisplay.pDisplay.Display,
fgStructure.GameModeWindow->Window.Handle,
RevertToNone,
CurrentTime
);
/* Move the Pointer to the middle of the fullscreen window */
XWarpPointer(
fgDisplay.pDisplay.Display,
None,
fgDisplay.pDisplay.RootWindow,
0, 0, 0, 0,
fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2
);
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if( fgDisplay.pDisplay.DisplayModeValid )
{
int x, y;
Window child;
/* Change to viewport to the window topleft edge: */
if( !XF86VidModeSetViewPort( fgDisplay.pDisplay.Display, fgDisplay.pDisplay.Screen, 0, 0 ) )
fgWarning( "XF86VidModeSetViewPort failed" );
/*
* Final window repositioning: It could be avoided using an undecorated
* window using override_redirect, but this * would possily require
* more changes and investigation.
*/
/* Get the current postion of the drawable area on screen */
XTranslateCoordinates(
fgDisplay.pDisplay.Display,
fgStructure.CurrentWindow->Window.Handle,
fgDisplay.pDisplay.RootWindow,
0, 0, &x, &y,
&child
);
/* Move the decorataions out of the topleft corner of the display */
XMoveWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
-x, -y);
}
#endif
/* Grab the keyboard, too */
XGrabKeyboard(
fgDisplay.pDisplay.Display,
fgStructure.GameModeWindow->Window.Handle,
FALSE,
GrabModeAsync, GrabModeAsync,
CurrentTime
);
}
/*
* Enters the game mode
*/
int FGAPIENTRY glutEnterGameMode( void )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutEnterGameMode" );
if( fgStructure.GameModeWindow )
fgAddToWindowDestroyList( fgStructure.GameModeWindow );
else
fghRememberState( );
if( ! fghChangeDisplayMode( GL_FALSE ) )
{
fgWarning( "failed to change screen settings" );
return 0;
}
fgStructure.GameModeWindow = fgCreateWindow(
NULL, "FREEGLUT", GL_TRUE, 0, 0,
GL_TRUE, fgState.GameModeSize.X, fgState.GameModeSize.Y,
GL_TRUE, GL_FALSE
);
fgStructure.GameModeWindow->State.Width = fgState.GameModeSize.X;
fgStructure.GameModeWindow->State.Height = fgState.GameModeSize.Y;
fgStructure.GameModeWindow->State.NeedToResize = GL_TRUE;
#if TARGET_HOST_POSIX_X11
/*
* Sync needed to avoid a real race, the Xserver must have really created
* the window before we can grab the pointer into it:
*/
XSync( fgDisplay.Display, False );
/*
* Grab the pointer to confine it into the window after the calls to
* XWrapPointer() which ensure that the pointer really enters the window.
*
* We also need to wait here until XGrabPointer() returns GrabSuccess,
* otherwise the new window is not viewable yet and if the next function
* (XSetInputFocus) is called with a not yet viewable window, it will exit
* the application which we have to aviod, so wait until it's viewable:
*/
while( GrabSuccess != XGrabPointer(
fgDisplay.Display, fgStructure.GameModeWindow->Window.Handle,
TRUE,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask
| PointerMotionMask,
GrabModeAsync, GrabModeAsync,
fgStructure.GameModeWindow->Window.Handle, None, CurrentTime) )
usleep( 100 );
/*
* Change input focus to the new window. This will exit the application
* if the new window is not viewable yet, see the XGrabPointer loop above.
*/
XSetInputFocus(
fgDisplay.Display,
fgStructure.GameModeWindow->Window.Handle,
RevertToNone,
CurrentTime
);
/* Move the Pointer to the middle of the fullscreen window */
XWarpPointer(
fgDisplay.Display,
None,
fgDisplay.RootWindow,
0, 0, 0, 0,
fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2
);
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if( fgDisplay.DisplayModeValid )
{
int x, y;
Window child;
/* Change to viewport to the window topleft edge: */
if( !XF86VidModeSetViewPort( fgDisplay.Display, fgDisplay.Screen, 0, 0 ) )
fgWarning( "XF86VidModeSetViewPort failed" );
/*
* Final window repositioning: It could be avoided using an undecorated
* window using override_redirect, but this * would possily require
* more changes and investigation.
*/
/* Get the current postion of the drawable area on screen */
XTranslateCoordinates(
fgDisplay.Display,
fgStructure.CurrentWindow->Window.Handle,
fgDisplay.RootWindow,
0, 0, &x, &y,
&child
);
/* Move the decorataions out of the topleft corner of the display */
XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
-x, -y);
}
#endif
/* Grab the keyboard, too */
XGrabKeyboard(
fgDisplay.Display,
fgStructure.GameModeWindow->Window.Handle,
FALSE,
GrabModeAsync, GrabModeAsync,
CurrentTime
);
#endif
return fgStructure.GameModeWindow->ID;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nSetInputFocus(JNIEnv *env, jclass clazz, jlong display, jlong window_ptr, jlong time) {
Display *disp = (Display *)(intptr_t)display;
Window window = (Window)window_ptr;
XSetInputFocus(disp, window, RevertToParent, time);
}
int main(int argc,char *argv[])
{
int screen;
int d_depth;
XWMHints mywmhints;
Pixel back_pix,fore_pix;
int i;
unsigned int borderwidth;
char *wname="wmswallow";
int remainarg, remainargc;
XEvent Event;
XTextProperty name;
XClassHint classHint;
remainarg=parseargs(argc, argv); /* remainarg > 0 afterwards */
remainargc=argc-remainarg;
#ifdef DEBUG
fprintf(stderr, "remainarg: %d, remainargc: %d, argc: %d\n", remainarg,
remainargc,argc);
fflush(stderr);
#endif
if (!(dpy = XOpenDisplay(display_name))) {
fprintf(stderr,"wmswallow: can't open display %s\n",
XDisplayName(display_name));
exit (1);
}
screen=DefaultScreen(dpy);
Root=RootWindow(dpy, screen);
/* So, now we've got everything we need to get Events from the XServer */
if (remainargc>1) {
winid=startandfind(remainargc-1, argv+remainarg+1, argv[remainarg]);
if (winid==0) {
perror("wmswallow: startandfind failed");
/* Real error handling in execstuff()*/
exit (1);
}
}
d_depth=DefaultDepth(dpy, screen);
/* XConnectionNumber(dpy); */ /* useless */
mysizehints.flags=USSize|USPosition;
mysizehints.x=0;
mysizehints.y=0;
back_pix=GetColor("white");
fore_pix=GetColor("black");
XWMGeometry(dpy, screen, geometry, NULL, (borderwidth =1),
&mysizehints, &mysizehints.x, &mysizehints.y,
&mysizehints.width, &mysizehints.height, &i);
mysizehints.width=WIDTH;
mysizehints.height=HEIGHT;
if (geometry!=NULL) {
#ifdef DEBUG
fprintf(stderr,"Setting geometry to: %s\n",geometry);
fflush(stderr);
#endif
XParseGeometry(geometry, &mysizehints.x, &mysizehints.y,
&mysizehints.width, &mysizehints.height);
}
win=XCreateSimpleWindow(dpy, Root, mysizehints.x, mysizehints.y,
mysizehints.width, mysizehints.height, borderwidth,
fore_pix, back_pix);
iconwin=XCreateSimpleWindow(dpy, win, mysizehints.x, mysizehints.y,
mysizehints.width, mysizehints.height, borderwidth,
fore_pix, back_pix);
XSetWMNormalHints(dpy, win, &mysizehints);
classHint.res_name="wmswallow";
classHint.res_class="WMswallow";
XSetClassHint(dpy, win, &classHint);
XSelectInput(dpy, win, MW_EVENTS);
XSelectInput(dpy, iconwin, MW_EVENTS);
if(XStringListToTextProperty(&wname, 1, &name)==0)
{
fprintf(stderr, "wmswallow: can't allocate window name\n");
exit(-1);
}
XSetWMName(dpy, win, &name);
mywmhints.initial_state = WithdrawnState;
mywmhints.icon_window = iconwin;
mywmhints.icon_x = mysizehints.x;
mywmhints.icon_y = mysizehints.y;
mywmhints.window_group = win;
mywmhints.flags = StateHint | IconWindowHint |
IconPositionHint | WindowGroupHint;
XSetWMHints(dpy, win, &mywmhints);
XSetCommand(dpy, win, argv, argc);
if (winid==0) {
swallowed=findnamedwindow(argv[remainarg]); /* Find which window to
swallow*/
#ifdef DEBUG
fprintf(stderr,"%s has Window-id 0x%lx\n", argv[remainarg], swallowed);
fflush(stderr);
#endif
}
else
swallowed=winid;
/* "Swallow" it */
XReparentWindow(dpy, swallowed, iconwin, 0, 0);
if (getclick) {
/* softenwindow (swallowed); */ /* Change some attributes */
XSelectInput(dpy, swallowed, SW_EVENTS|ButtonPressMask);
}
else {
XSelectInput(dpy, swallowed, SW_EVENTS); /* Workaround for apps like
perfmeter that don't let us
get their mouseclicks :-( */
}
XSetWindowBorderWidth(dpy, swallowed,0);
XMoveResizeWindow(dpy, swallowed, 0, 0,
mysizehints.width, mysizehints.height);
/* Now we do some special juju for shaped windows: */
/* ...tell the window to repaint itself, please! */
if (shape) {
sendexpose(swallowed);
/* ... ok, window should be repainted and a shaped window should have updated
its mask accordingly! (-: End of shape-juju :-) */
/* Now steal the shape of the Window we just swallowed! */
stealshape(swallowed); }
XMapWindow(dpy,win);
XMapSubwindows(dpy,win);
FlushWindow();
while(1)
{
while (XPending(dpy))
{
XNextEvent(dpy,&Event);
switch(Event.type)
{
case ButtonPress:
#ifdef DEBUG
fprintf (stderr, "wmswallow: Got ButtonPress Event\n");
fflush(stderr);
#endif
if (getclick)
system(execstring);
break;
case Expose:
if(Event.xexpose.count == 0 ) {
#ifdef DEBUG
fprintf (stderr, "wmswallow: Got Expose Event, count==0\n");
fflush(stderr);
#endif
if (shape)
stealshape(swallowed); /* Oclock changes its shape! That's why
we have to steal it *again* */
FlushWindow();
XMapRaised(dpy,swallowed);
/* the following Produces "focus-flicker" */
/* XMapSubwindows(dpy,win); */
/* XMapWindow(dpy,win); */
}
break;
case EnterNotify:
if (focus)
XSetInputFocus(dpy, swallowed, RevertToPointerRoot,
CurrentTime);
break;
case LeaveNotify:
if (focus)
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot,
CurrentTime);
break;
case DestroyNotify:
XCloseDisplay(dpy);
exit(0);
default:
#ifdef DEBUG
/* fprintf (stderr, "wmswallow: Got Some Other Event\n");
fflush(stderr); */
#endif
break;
}
}
XFlush(dpy);
usleep(50000L);
}
return 1;
}
static bool gfx_ctx_x_set_video_mode(void *data,
video_frame_info_t *video_info,
unsigned width, unsigned height,
bool fullscreen)
{
XEvent event;
bool true_full = false;
bool windowed_full = false;
int val = 0;
int x_off = 0;
int y_off = 0;
XVisualInfo *vi = NULL;
XSetWindowAttributes swa = {0};
char *wm_name = NULL;
int (*old_handler)(Display*, XErrorEvent*) = NULL;
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
Atom net_wm_icon = XInternAtom(g_x11_dpy, "_NET_WM_ICON", False);
Atom cardinal = XInternAtom(g_x11_dpy, "CARDINAL", False);
settings_t *settings = config_get_ptr();
unsigned opacity = settings->uints.video_window_opacity * ((unsigned)-1 / 100.0);
frontend_driver_install_signal_handler();
if (!x)
return false;
windowed_full = video_info->windowed_fullscreen;
true_full = false;
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
vi = glXGetVisualFromFBConfig(g_x11_dpy, x->g_fbc);
if (!vi)
goto error;
#endif
break;
case GFX_CTX_NONE:
default:
{
XVisualInfo vi_template;
/* For default case, just try to obtain a visual from template. */
int nvisuals = 0;
memset(&vi_template, 0, sizeof(vi_template));
vi_template.screen = DefaultScreen(g_x11_dpy);
vi = XGetVisualInfo(g_x11_dpy, VisualScreenMask, &vi_template, &nvisuals);
if (!vi || nvisuals < 1)
goto error;
}
break;
}
swa.colormap = g_x11_cmap = XCreateColormap(g_x11_dpy,
RootWindow(g_x11_dpy, vi->screen), vi->visual, AllocNone);
swa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
LeaveWindowMask | EnterWindowMask |
ButtonReleaseMask | ButtonPressMask;
swa.override_redirect = False;
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(video_info, g_x11_dpy, width, height))
{
x->g_should_reset_mode = true;
true_full = true;
}
else
RARCH_ERR("[GLX]: Entering true fullscreen failed. Will attempt windowed mode.\n");
}
wm_name = x11_get_wm_name(g_x11_dpy);
if (wm_name)
{
RARCH_LOG("[GLX]: Window manager is %s.\n", wm_name);
if (true_full && strcasestr(wm_name, "xfwm"))
{
RARCH_LOG("[GLX]: Using override-redirect workaround.\n");
swa.override_redirect = True;
}
free(wm_name);
}
if (!x11_has_net_wm_fullscreen(g_x11_dpy) && true_full)
swa.override_redirect = True;
if (video_info->monitor_index)
g_x11_screen = video_info->monitor_index - 1;
#ifdef HAVE_XINERAMA
if (fullscreen || g_x11_screen != 0)
{
unsigned new_width = width;
unsigned new_height = height;
if (xinerama_get_coord(g_x11_dpy, g_x11_screen,
&x_off, &y_off, &new_width, &new_height))
RARCH_LOG("[GLX]: Using Xinerama on screen #%u.\n", g_x11_screen);
else
RARCH_LOG("[GLX]: Xinerama is not active on screen.\n");
if (fullscreen)
{
width = new_width;
height = new_height;
}
}
#endif
RARCH_LOG("[GLX]: X = %d, Y = %d, W = %u, H = %u.\n",
x_off, y_off, width, height);
g_x11_win = XCreateWindow(g_x11_dpy, RootWindow(g_x11_dpy, vi->screen),
x_off, y_off, width, height, 0,
vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect,
&swa);
XSetWindowBackground(g_x11_dpy, g_x11_win, 0);
XChangeProperty(g_x11_dpy, g_x11_win, net_wm_icon, cardinal, 32, PropModeReplace, (const unsigned char*)retroarch_icon_data, sizeof(retroarch_icon_data) / sizeof(*retroarch_icon_data));
if (fullscreen && settings->bools.video_disable_composition)
{
uint32_t value = 1;
Atom net_wm_bypass_compositor = XInternAtom(g_x11_dpy, "_NET_WM_BYPASS_COMPOSITOR", False);
RARCH_LOG("[GLX]: Requesting compositor bypass.\n");
XChangeProperty(g_x11_dpy, g_x11_win, net_wm_bypass_compositor, cardinal, 32, PropModeReplace, (const unsigned char*)&value, 1);
}
if (opacity < (unsigned)-1)
{
Atom net_wm_opacity = XInternAtom(g_x11_dpy, "_NET_WM_WINDOW_OPACITY", False);
XChangeProperty(g_x11_dpy, g_x11_win, net_wm_opacity, cardinal, 32, PropModeReplace, (const unsigned char*)&opacity, 1);
}
if (!settings->bools.video_window_show_decorations)
{
/* We could have just set _NET_WM_WINDOW_TYPE_DOCK instead, but that removes the window from any taskbar/panel,
* so we are forced to use the old motif hints method. */
Hints hints;
Atom property = XInternAtom(g_x11_dpy, "_MOTIF_WM_HINTS", False);
hints.flags = 2;
hints.decorations = 0;
XChangeProperty(g_x11_dpy, g_x11_win, property, property, 32, PropModeReplace, (const unsigned char*)&hints, 5);
}
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
x->g_glx_win = glXCreateWindow(g_x11_dpy, x->g_fbc, g_x11_win, 0);
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
x11_set_window_attr(g_x11_dpy, g_x11_win);
x11_update_title(NULL, video_info);
if (fullscreen)
x11_show_mouse(g_x11_dpy, g_x11_win, false);
if (true_full)
{
RARCH_LOG("[GLX]: Using true fullscreen.\n");
XMapRaised(g_x11_dpy, g_x11_win);
x11_set_net_wm_fullscreen(g_x11_dpy, g_x11_win);
}
else if (fullscreen)
{
/* We attempted true fullscreen, but failed.
* Attempt using windowed fullscreen. */
XMapRaised(g_x11_dpy, g_x11_win);
RARCH_LOG("[GLX]: Using windowed fullscreen.\n");
/* We have to move the window to the screen we want
* to go fullscreen on first.
* x_off and y_off usually get ignored in XCreateWindow().
*/
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
x11_set_net_wm_fullscreen(g_x11_dpy, g_x11_win);
}
else
{
XMapWindow(g_x11_dpy, g_x11_win);
/* If we want to map the window on a different screen,
* we'll have to do it by force.
* Otherwise, we should try to let the window manager sort it out.
* x_off and y_off usually get ignored in XCreateWindow(). */
if (g_x11_screen)
x11_move_window(g_x11_dpy, g_x11_win, x_off, y_off, width, height);
}
x11_event_queue_check(&event);
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
if (!x->g_ctx)
{
if (x->g_core_es || x->g_debug)
{
int attribs[16];
int *aptr = attribs;
if (x->g_core_es)
{
*aptr++ = GLX_CONTEXT_MAJOR_VERSION_ARB;
*aptr++ = g_major;
*aptr++ = GLX_CONTEXT_MINOR_VERSION_ARB;
*aptr++ = g_minor;
if (x->g_core_es_core)
{
/* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending on
* GL_ARB_compatibility.
*/
*aptr++ = GLX_CONTEXT_PROFILE_MASK_ARB;
#ifdef HAVE_OPENGLES2
*aptr++ = GLX_CONTEXT_ES_PROFILE_BIT_EXT;
#else
*aptr++ = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
#endif
}
}
if (x->g_debug)
{
*aptr++ = GLX_CONTEXT_FLAGS_ARB;
*aptr++ = GLX_CONTEXT_DEBUG_BIT_ARB;
}
*aptr = None;
x->g_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, NULL, True, attribs);
if (x->g_use_hw_ctx)
{
RARCH_LOG("[GLX]: Creating shared HW context.\n");
x->g_hw_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, x->g_ctx, True, attribs);
if (!x->g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n");
}
}
else
{
x->g_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc,
GLX_RGBA_TYPE, 0, True);
if (x->g_use_hw_ctx)
{
x->g_hw_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc,
GLX_RGBA_TYPE, x->g_ctx, True);
if (!x->g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n");
}
}
if (!x->g_ctx)
{
RARCH_ERR("[GLX]: Failed to create new context.\n");
goto error;
}
}
else
{
video_driver_set_video_cache_context_ack();
RARCH_LOG("[GLX]: Using cached GL context.\n");
}
glXMakeContextCurrent(g_x11_dpy,
x->g_glx_win, x->g_glx_win, x->g_ctx);
#endif
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN
{
bool quit, resize;
bool shutdown = false;
unsigned width = 0, height = 0;
x11_check_window(x, &quit, &resize, &width, &height,
shutdown);
/* FIXME/TODO - threading error here */
/* Use XCB surface since it's the most supported WSI.
* We can obtain the XCB connection directly from X11. */
if (!vulkan_surface_create(&x->vk, VULKAN_WSI_XCB,
g_x11_dpy, &g_x11_win,
width, height, x->g_interval))
goto error;
}
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
XSync(g_x11_dpy, False);
x11_install_quit_atom();
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGL
glXGetConfig(g_x11_dpy, vi, GLX_DOUBLEBUFFER, &val);
x->g_is_double = val;
if (x->g_is_double)
{
const char *swap_func = NULL;
g_pglSwapIntervalEXT = (void (*)(Display*, GLXDrawable, int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");
g_pglSwapIntervalSGI = (int (*)(int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalSGI");
g_pglSwapInterval = (int (*)(int))
glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
if (g_pglSwapIntervalEXT)
swap_func = "glXSwapIntervalEXT";
else if (g_pglSwapInterval)
swap_func = "glXSwapIntervalMESA";
else if (g_pglSwapIntervalSGI)
swap_func = "glXSwapIntervalSGI";
if (!g_pglSwapInterval && !g_pglSwapIntervalEXT && !g_pglSwapIntervalSGI)
RARCH_WARN("[GLX]: Cannot find swap interval call.\n");
else
RARCH_LOG("[GLX]: Found swap function: %s.\n", swap_func);
}
else
RARCH_WARN("[GLX]: Context is not double buffered!.\n");
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
gfx_ctx_x_swap_interval(data, x->g_interval);
/* This can blow up on some drivers.
* It's not fatal, so override errors for this call. */
old_handler = XSetErrorHandler(x_nul_handler);
XSetInputFocus(g_x11_dpy, g_x11_win, RevertToNone, CurrentTime);
XSync(g_x11_dpy, False);
XSetErrorHandler(old_handler);
XFree(vi);
vi = NULL;
if (!x11_input_ctx_new(true_full))
goto error;
return true;
error:
if (vi)
XFree(vi);
gfx_ctx_x_destroy_resources(x);
if (x)
free(x);
g_x11_screen = 0;
return false;
}