2009-02-08 03:27:30 +00:00
|
|
|
/*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* MPlayer is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
2001-04-15 20:31:58 +00:00
|
|
|
|
2001-03-03 21:47:37 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2002-10-29 20:27:47 +00:00
|
|
|
#include <math.h>
|
2002-06-12 22:57:58 +00:00
|
|
|
#include <inttypes.h>
|
2008-11-15 19:06:25 +00:00
|
|
|
#include <limits.h>
|
2001-04-15 18:35:17 +00:00
|
|
|
|
2001-04-15 20:31:58 +00:00
|
|
|
#include "config.h"
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/bstr.h"
|
|
|
|
#include "core/options.h"
|
|
|
|
#include "core/mp_msg.h"
|
|
|
|
#include "core/mp_fifo.h"
|
2009-01-09 15:25:24 +00:00
|
|
|
#include "libavutil/common.h"
|
2002-06-12 22:57:58 +00:00
|
|
|
#include "x11_common.h"
|
2008-04-29 13:22:33 +00:00
|
|
|
#include "talloc.h"
|
2001-04-15 20:31:58 +00:00
|
|
|
|
|
|
|
#include <string.h>
|
2001-03-03 21:47:37 +00:00
|
|
|
#include <unistd.h>
|
2004-06-02 02:34:39 +00:00
|
|
|
#include <assert.h>
|
2001-03-03 21:47:37 +00:00
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "vo.h"
|
2003-09-20 10:24:10 +00:00
|
|
|
#include "aspect.h"
|
2004-10-28 01:15:53 +00:00
|
|
|
#include "osdep/timer.h"
|
2001-03-03 21:47:37 +00:00
|
|
|
|
2001-04-10 00:00:04 +00:00
|
|
|
#include <X11/Xmd.h>
|
2001-03-03 21:47:37 +00:00
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
|
|
|
#include <X11/Xatom.h>
|
2012-01-13 08:25:12 +00:00
|
|
|
#include <X11/keysym.h>
|
2001-03-03 21:47:37 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XSS
|
2007-12-22 18:51:05 +00:00
|
|
|
#include <X11/extensions/scrnsaver.h>
|
|
|
|
#endif
|
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XDPMS
|
2001-04-15 20:31:58 +00:00
|
|
|
#include <X11/extensions/dpms.h>
|
2001-07-19 18:47:22 +00:00
|
|
|
#endif
|
2001-04-15 20:31:58 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XINERAMA
|
2001-10-10 01:48:54 +00:00
|
|
|
#include <X11/extensions/Xinerama.h>
|
|
|
|
#endif
|
2001-08-28 17:52:20 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2002-01-31 00:37:27 +00:00
|
|
|
#include <X11/extensions/xf86vmode.h>
|
2005-02-02 14:07:13 +00:00
|
|
|
#endif
|
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86XK
|
2003-04-04 15:04:26 +00:00
|
|
|
#include <X11/XF86keysym.h>
|
2002-01-31 00:37:27 +00:00
|
|
|
#endif
|
|
|
|
|
2012-11-09 00:06:43 +00:00
|
|
|
#include "core/input/input.h"
|
|
|
|
#include "core/input/keycodes.h"
|
2002-02-11 11:44:50 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
#define vo_wm_LAYER 1
|
|
|
|
#define vo_wm_FULLSCREEN 2
|
|
|
|
#define vo_wm_STAYS_ON_TOP 4
|
|
|
|
#define vo_wm_ABOVE 8
|
|
|
|
#define vo_wm_BELOW 16
|
|
|
|
#define vo_wm_NETWM (vo_wm_FULLSCREEN | vo_wm_STAYS_ON_TOP | vo_wm_ABOVE | vo_wm_BELOW)
|
|
|
|
|
|
|
|
/* EWMH state actions, see
|
|
|
|
http://freedesktop.org/Standards/wm-spec/index.html#id2768769 */
|
|
|
|
#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
|
|
|
|
#define _NET_WM_STATE_ADD 1 /* add/set property */
|
|
|
|
#define _NET_WM_STATE_TOGGLE 2 /* toggle property */
|
|
|
|
|
2002-12-30 18:50:15 +00:00
|
|
|
#define WIN_LAYER_ONBOTTOM 2
|
|
|
|
#define WIN_LAYER_NORMAL 4
|
|
|
|
#define WIN_LAYER_ONTOP 6
|
This time the patch is fixing much more that breaking :-)
It includes ugly hack for OpenBox, swaps checking for netwm
with layers (and makes fvwm work -> they have also broken
_NET_WM_STATE_FULLSCREEN but also supports layers) and changes
back fullscreen layer to 10, afterstep doesn't like 12 :-)
Tested with: sawfish, metacity, kwin, blackbox, openbox, waimea,
windowmaker, afterstep, icewm, mwm, fvwm
Filip Kalinski <filon@pld.org.pl>
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8670 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-12-30 23:59:53 +00:00
|
|
|
#define WIN_LAYER_ABOVE_DOCK 10
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
// ----- Motif header: -------
|
|
|
|
|
|
|
|
#define MWM_HINTS_FUNCTIONS (1L << 0)
|
|
|
|
#define MWM_HINTS_DECORATIONS (1L << 1)
|
|
|
|
#define MWM_HINTS_INPUT_MODE (1L << 2)
|
|
|
|
#define MWM_HINTS_STATUS (1L << 3)
|
|
|
|
|
|
|
|
#define MWM_FUNC_ALL (1L << 0)
|
|
|
|
#define MWM_FUNC_RESIZE (1L << 1)
|
|
|
|
#define MWM_FUNC_MOVE (1L << 2)
|
|
|
|
#define MWM_FUNC_MINIMIZE (1L << 3)
|
|
|
|
#define MWM_FUNC_MAXIMIZE (1L << 4)
|
|
|
|
#define MWM_FUNC_CLOSE (1L << 5)
|
2003-01-09 21:23:54 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
#define MWM_DECOR_ALL (1L << 0)
|
|
|
|
#define MWM_DECOR_BORDER (1L << 1)
|
|
|
|
#define MWM_DECOR_RESIZEH (1L << 2)
|
|
|
|
#define MWM_DECOR_TITLE (1L << 3)
|
|
|
|
#define MWM_DECOR_MENU (1L << 4)
|
|
|
|
#define MWM_DECOR_MINIMIZE (1L << 5)
|
|
|
|
#define MWM_DECOR_MAXIMIZE (1L << 6)
|
2002-05-27 11:19:56 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
#define MWM_INPUT_MODELESS 0
|
|
|
|
#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
|
|
|
|
#define MWM_INPUT_SYSTEM_MODAL 2
|
|
|
|
#define MWM_INPUT_FULL_APPLICATION_MODAL 3
|
|
|
|
#define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
|
2001-04-10 00:00:04 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
#define MWM_TEAROFF_WINDOW (1L<<0)
|
2001-04-13 00:54:05 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
long flags;
|
|
|
|
long functions;
|
|
|
|
long decorations;
|
|
|
|
long input_mode;
|
|
|
|
long state;
|
|
|
|
} MotifWmHints;
|
2003-01-07 20:58:25 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_update_geometry(struct vo *vo, bool update_pos);
|
|
|
|
static int vo_x11_get_fs_type(struct vo *vo);
|
|
|
|
static void saver_on(struct vo_x11_state *x11);
|
|
|
|
static void saver_off(struct vo_x11_state *x11);
|
|
|
|
static void vo_x11_selectinput_witherr(Display *display, Window w,
|
|
|
|
long event_mask);
|
|
|
|
static void vo_x11_setlayer(struct vo *vo, Window vo_window, int layer);
|
2013-01-27 06:21:10 +00:00
|
|
|
static void vo_x11_vm_switch(struct vo *vo);
|
|
|
|
static void vo_x11_vm_close(struct vo *vo);
|
2013-01-27 11:01:08 +00:00
|
|
|
static void vo_x11_create_colormap(struct vo_x11_state *x11,
|
|
|
|
XVisualInfo *vinfo);
|
2003-05-30 18:05:49 +00:00
|
|
|
|
2004-06-02 02:34:39 +00:00
|
|
|
/*
|
|
|
|
* Sends the EWMH fullscreen state event.
|
2007-01-18 09:03:42 +00:00
|
|
|
*
|
|
|
|
* action: could be one of _NET_WM_STATE_REMOVE -- remove state
|
|
|
|
* _NET_WM_STATE_ADD -- add state
|
|
|
|
* _NET_WM_STATE_TOGGLE -- toggle
|
2004-06-02 02:34:39 +00:00
|
|
|
*/
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_ewmh_fullscreen(struct vo_x11_state *x11, int action)
|
2004-06-02 02:34:39 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
assert(action == _NET_WM_STATE_REMOVE ||
|
|
|
|
action == _NET_WM_STATE_ADD || action == _NET_WM_STATE_TOGGLE);
|
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
if (x11->fs_type & vo_wm_FULLSCREEN)
|
2004-06-02 02:34:39 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
XEvent xev;
|
|
|
|
|
2007-01-18 09:03:42 +00:00
|
|
|
/* init X event structure for _NET_WM_FULLSCREEN client message */
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.xclient.type = ClientMessage;
|
|
|
|
xev.xclient.serial = 0;
|
|
|
|
xev.xclient.send_event = True;
|
2008-09-20 13:13:33 +00:00
|
|
|
xev.xclient.message_type = x11->XA_NET_WM_STATE;
|
2008-04-21 00:14:37 +00:00
|
|
|
xev.xclient.window = x11->window;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.xclient.format = 32;
|
|
|
|
xev.xclient.data.l[0] = action;
|
2008-09-20 13:13:33 +00:00
|
|
|
xev.xclient.data.l[1] = x11->XA_NET_WM_STATE_FULLSCREEN;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.xclient.data.l[2] = 0;
|
|
|
|
xev.xclient.data.l[3] = 0;
|
|
|
|
xev.xclient.data.l[4] = 0;
|
|
|
|
|
|
|
|
/* finally send that damn thing */
|
2008-04-21 00:14:37 +00:00
|
|
|
if (!XSendEvent(x11->display, DefaultRootWindow(x11->display), False,
|
2004-06-14 04:53:03 +00:00
|
|
|
SubstructureRedirectMask | SubstructureNotifyMask,
|
|
|
|
&xev))
|
|
|
|
{
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_VO, MSGL_ERR, "\nX11: Couldn't send EWMH fullscreen event!\n");
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2004-06-02 02:34:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-20 03:39:29 +00:00
|
|
|
static void vo_hidecursor(Display * disp, Window win)
|
2001-04-13 00:54:05 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
Cursor no_ptr;
|
|
|
|
Pixmap bm_no;
|
|
|
|
XColor black, dummy;
|
|
|
|
Colormap colormap;
|
2008-04-21 00:53:13 +00:00
|
|
|
const char bm_no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
if (WinID == 0)
|
2007-01-18 09:03:42 +00:00
|
|
|
return; // do not hide if playing on the root window
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
colormap = DefaultColormap(disp, DefaultScreen(disp));
|
2005-02-20 22:58:55 +00:00
|
|
|
if ( !XAllocNamedColor(disp, colormap, "black", &black, &dummy) )
|
|
|
|
{
|
2010-07-01 19:52:18 +00:00
|
|
|
return; // color alloc failed, give up
|
2005-02-20 22:58:55 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
bm_no = XCreateBitmapFromData(disp, win, bm_no_data, 8, 8);
|
|
|
|
no_ptr = XCreatePixmapCursor(disp, bm_no, bm_no, &black, &black, 0, 0);
|
|
|
|
XDefineCursor(disp, win, no_ptr);
|
|
|
|
XFreeCursor(disp, no_ptr);
|
|
|
|
if (bm_no != None)
|
|
|
|
XFreePixmap(disp, bm_no);
|
2004-11-15 14:56:18 +00:00
|
|
|
XFreeColors(disp,colormap,&black.pixel,1,0);
|
2001-04-13 00:54:05 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 03:39:29 +00:00
|
|
|
static void vo_showcursor(Display * disp, Window win)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
if (WinID == 0)
|
|
|
|
return;
|
|
|
|
XDefineCursor(disp, win, 0);
|
2002-05-03 20:57:13 +00:00
|
|
|
}
|
2001-04-13 00:54:05 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
static int x11_errorhandler(Display * display, XErrorEvent * event)
|
2002-02-17 12:34:29 +00:00
|
|
|
{
|
|
|
|
#define MSGLEN 60
|
|
|
|
char msg[MSGLEN];
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
XGetErrorText(display, event->error_code, (char *) &msg, MSGLEN);
|
|
|
|
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR, "X11 error: %s\n", msg);
|
|
|
|
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
2006-01-12 20:04:36 +00:00
|
|
|
"Type: %x, display: %p, resourceid: %lx, serial: %lx\n",
|
2004-06-14 04:53:03 +00:00
|
|
|
event->type, event->display, event->resourceid, event->serial);
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"Error code: %x, request code: %x, minor code: %x\n",
|
|
|
|
event->error_code, event->request_code, event->minor_code);
|
|
|
|
|
2007-01-05 11:57:06 +00:00
|
|
|
// abort();
|
2007-06-24 10:46:40 +00:00
|
|
|
return 0;
|
2002-02-17 12:34:29 +00:00
|
|
|
#undef MSGLEN
|
|
|
|
}
|
2001-08-28 17:52:20 +00:00
|
|
|
|
2003-02-07 19:38:39 +00:00
|
|
|
void fstype_help(void)
|
|
|
|
{
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_VO, MSGL_INFO, "Available fullscreen layer change modes:\n");
|
2006-04-24 07:20:34 +00:00
|
|
|
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_FULL_SCREEN_TYPES\n");
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "none",
|
|
|
|
"don't set fullscreen window layer");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "layer",
|
|
|
|
"use _WIN_LAYER hint with default layer");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "layer=<0..15>",
|
|
|
|
"use _WIN_LAYER hint with a given layer number");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "netwm",
|
|
|
|
"force NETWM style");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "above",
|
|
|
|
"use _NETWM_STATE_ABOVE hint if available");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "below",
|
|
|
|
"use _NETWM_STATE_BELOW hint if available");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "fullscreen",
|
2010-08-03 15:55:17 +00:00
|
|
|
"use _NETWM_STATE_FULLSCREEN hint if available");
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "stays_on_top",
|
|
|
|
"use _NETWM_STATE_STAYS_ON_TOP hint if available");
|
|
|
|
mp_msg(MSGT_VO, MSGL_INFO,
|
|
|
|
"You can also negate the settings with simply putting '-' in the beginning");
|
2006-03-04 17:33:56 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, "\n");
|
2003-08-25 18:13:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void fstype_dump(int fstype)
|
|
|
|
{
|
|
|
|
if (fstype)
|
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "[x11] Current fstype setting honours");
|
|
|
|
if (fstype & vo_wm_LAYER)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " LAYER");
|
|
|
|
if (fstype & vo_wm_FULLSCREEN)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " FULLSCREEN");
|
|
|
|
if (fstype & vo_wm_STAYS_ON_TOP)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " STAYS_ON_TOP");
|
|
|
|
if (fstype & vo_wm_ABOVE)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " ABOVE");
|
|
|
|
if (fstype & vo_wm_BELOW)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " BELOW");
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, " X atoms\n");
|
|
|
|
} else
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"[x11] Current fstype setting doesn't honour any X atoms\n");
|
2003-02-07 19:38:39 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-20 23:50:40 +00:00
|
|
|
static int net_wm_support_state_test(struct vo_x11_state *x11, Atom atom)
|
2002-12-30 00:47:43 +00:00
|
|
|
{
|
2008-04-20 23:50:40 +00:00
|
|
|
#define NET_WM_STATE_TEST(x) { if (atom == x11->XA_NET_WM_STATE_##x) { mp_msg( MSGT_VO,MSGL_V, "[x11] Detected wm supports " #x " state.\n" ); return vo_wm_##x; } }
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
NET_WM_STATE_TEST(FULLSCREEN);
|
|
|
|
NET_WM_STATE_TEST(ABOVE);
|
|
|
|
NET_WM_STATE_TEST(STAYS_ON_TOP);
|
|
|
|
NET_WM_STATE_TEST(BELOW);
|
|
|
|
return 0;
|
2002-12-30 00:47:43 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
static int x11_get_property(struct vo_x11_state *x11, Atom type, Atom ** args,
|
|
|
|
unsigned long *nitems)
|
2003-01-03 15:30:57 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
int format;
|
|
|
|
unsigned long bytesafter;
|
|
|
|
|
2008-05-16 08:33:27 +00:00
|
|
|
return Success ==
|
2008-04-21 01:59:00 +00:00
|
|
|
XGetWindowProperty(x11->display, x11->rootwin, type, 0, 16384, False,
|
2004-06-14 04:53:03 +00:00
|
|
|
AnyPropertyType, &type, &format, nitems,
|
|
|
|
&bytesafter, (unsigned char **) args)
|
2008-05-16 08:33:27 +00:00
|
|
|
&& *nitems > 0;
|
2003-01-03 15:30:57 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
static int vo_wm_detect(struct vo *vo)
|
2002-05-07 13:31:29 +00:00
|
|
|
{
|
2008-04-20 23:50:40 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
int i;
|
|
|
|
int wm = 0;
|
|
|
|
unsigned long nitems;
|
|
|
|
Atom *args = NULL;
|
|
|
|
|
|
|
|
if (WinID >= 0)
|
|
|
|
return 0;
|
This time the patch is fixing much more that breaking :-)
It includes ugly hack for OpenBox, swaps checking for netwm
with layers (and makes fvwm work -> they have also broken
_NET_WM_STATE_FULLSCREEN but also supports layers) and changes
back fullscreen layer to 10, afterstep doesn't like 12 :-)
Tested with: sawfish, metacity, kwin, blackbox, openbox, waimea,
windowmaker, afterstep, icewm, mwm, fvwm
Filip Kalinski <filon@pld.org.pl>
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8670 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-12-30 23:59:53 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
// -- supports layers
|
2008-04-20 23:50:40 +00:00
|
|
|
if (x11_get_property(x11, x11->XA_WIN_PROTOCOLS, &args, &nitems))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports layers.\n");
|
2013-01-26 21:37:47 +00:00
|
|
|
int metacity_hack = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
for (i = 0; i < nitems; i++)
|
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
if (args[i] == x11->XA_WIN_LAYER) {
|
2004-06-14 04:53:03 +00:00
|
|
|
wm |= vo_wm_LAYER;
|
|
|
|
metacity_hack |= 1;
|
2013-01-26 21:37:47 +00:00
|
|
|
} else {
|
2007-01-18 09:03:42 +00:00
|
|
|
/* metacity is the only window manager I know which reports
|
|
|
|
* supporting only the _WIN_LAYER hint in _WIN_PROTOCOLS.
|
|
|
|
* (what's more support for it is broken) */
|
2004-06-14 04:53:03 +00:00
|
|
|
metacity_hack |= 2;
|
2013-01-26 21:37:47 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
XFree(args);
|
|
|
|
if (wm && (metacity_hack == 1))
|
|
|
|
{
|
2007-01-18 09:03:42 +00:00
|
|
|
// metacity claims to support layers, but it is not the truth :-)
|
2004-06-14 04:53:03 +00:00
|
|
|
wm ^= vo_wm_LAYER;
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"[x11] Using workaround for Metacity bugs.\n");
|
|
|
|
}
|
|
|
|
}
|
2009-07-06 23:26:13 +00:00
|
|
|
// --- netwm
|
2008-04-20 23:50:40 +00:00
|
|
|
if (x11_get_property(x11, x11->XA_NET_SUPPORTED, &args, &nitems))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports NetWM.\n");
|
|
|
|
for (i = 0; i < nitems; i++)
|
2008-04-20 23:50:40 +00:00
|
|
|
wm |= net_wm_support_state_test(vo->x11, args[i]);
|
2004-06-14 04:53:03 +00:00
|
|
|
XFree(args);
|
|
|
|
}
|
2003-02-07 19:38:39 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if (wm == 0)
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "[x11] Unknown wm type...\n");
|
|
|
|
return wm;
|
|
|
|
}
|
2002-05-07 13:31:29 +00:00
|
|
|
|
2008-04-20 23:50:40 +00:00
|
|
|
#define XA_INIT(x) x11->XA##x = XInternAtom(x11->display, #x, False)
|
|
|
|
static void init_atoms(struct vo_x11_state *x11)
|
2003-01-03 15:30:57 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
XA_INIT(_NET_SUPPORTED);
|
|
|
|
XA_INIT(_NET_WM_STATE);
|
|
|
|
XA_INIT(_NET_WM_STATE_FULLSCREEN);
|
|
|
|
XA_INIT(_NET_WM_STATE_ABOVE);
|
|
|
|
XA_INIT(_NET_WM_STATE_STAYS_ON_TOP);
|
|
|
|
XA_INIT(_NET_WM_STATE_BELOW);
|
|
|
|
XA_INIT(_NET_WM_PID);
|
2011-12-06 17:48:31 +00:00
|
|
|
XA_INIT(_NET_WM_NAME);
|
|
|
|
XA_INIT(_NET_WM_ICON_NAME);
|
2004-06-14 04:53:03 +00:00
|
|
|
XA_INIT(_WIN_PROTOCOLS);
|
|
|
|
XA_INIT(_WIN_LAYER);
|
|
|
|
XA_INIT(_WIN_HINTS);
|
2006-04-19 15:58:10 +00:00
|
|
|
XA_INIT(WM_PROTOCOLS);
|
|
|
|
XA_INIT(WM_DELETE_WINDOW);
|
2011-12-06 17:48:31 +00:00
|
|
|
XA_INIT(UTF8_STRING);
|
2012-07-27 00:40:38 +00:00
|
|
|
char buf[50];
|
|
|
|
sprintf(buf, "_NET_WM_CM_S%d", x11->screen);
|
|
|
|
x11->XA_NET_WM_CM = XInternAtom(x11->display, buf, False);
|
2003-01-03 15:30:57 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
void vo_x11_update_screeninfo(struct vo *vo) {
|
2008-04-20 23:18:28 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2006-04-16 13:38:28 +00:00
|
|
|
xinerama_x = xinerama_y = 0;
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XINERAMA
|
2010-05-07 18:01:44 +00:00
|
|
|
if (xinerama_screen >= -1 && XineramaIsActive(vo->x11->display))
|
2006-04-16 13:38:28 +00:00
|
|
|
{
|
2010-04-27 19:04:23 +00:00
|
|
|
int screen = xinerama_screen;
|
2006-04-16 13:38:28 +00:00
|
|
|
XineramaScreenInfo *screens;
|
|
|
|
int num_screens;
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
screens = XineramaQueryScreens(vo->x11->display, &num_screens);
|
2008-04-19 09:58:01 +00:00
|
|
|
if (screen >= num_screens)
|
|
|
|
screen = num_screens - 1;
|
|
|
|
if (screen == -1) {
|
2008-04-20 20:29:28 +00:00
|
|
|
int x = vo->dx + vo->dwidth / 2;
|
|
|
|
int y = vo->dy + vo->dheight / 2;
|
2008-04-19 09:58:01 +00:00
|
|
|
for (screen = num_screens - 1; screen > 0; screen--) {
|
|
|
|
int left = screens[screen].x_org;
|
|
|
|
int right = left + screens[screen].width;
|
|
|
|
int top = screens[screen].y_org;
|
|
|
|
int bottom = top + screens[screen].height;
|
|
|
|
if (left <= x && x <= right && top <= y && y <= bottom)
|
|
|
|
break;
|
|
|
|
}
|
2008-04-13 11:15:08 +00:00
|
|
|
}
|
2006-04-16 13:38:28 +00:00
|
|
|
if (screen < 0)
|
|
|
|
screen = 0;
|
2008-04-20 23:18:28 +00:00
|
|
|
opts->vo_screenwidth = screens[screen].width;
|
|
|
|
opts->vo_screenheight = screens[screen].height;
|
2006-04-16 13:38:28 +00:00
|
|
|
xinerama_x = screens[screen].x_org;
|
|
|
|
xinerama_y = screens[screen].y_org;
|
|
|
|
|
|
|
|
XFree(screens);
|
|
|
|
}
|
|
|
|
#endif
|
2008-05-01 08:02:26 +00:00
|
|
|
aspect_save_screenres(vo, opts->vo_screenwidth, opts->vo_screenheight);
|
2006-04-16 13:38:28 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
int vo_x11_init(struct vo *vo)
|
2001-03-03 21:47:37 +00:00
|
|
|
{
|
2008-04-20 23:18:28 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2004-06-14 04:53:03 +00:00
|
|
|
char *dispName;
|
2009-07-06 23:26:13 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
assert(!vo->x11);
|
2012-08-03 03:55:02 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
struct vo_x11_state *x11 = talloc_ptrtype(NULL, x11);
|
|
|
|
*x11 = (struct vo_x11_state){
|
|
|
|
.olddecor = MWM_DECOR_ALL,
|
|
|
|
.oldfuncs = MWM_FUNC_MOVE | MWM_FUNC_CLOSE | MWM_FUNC_MINIMIZE |
|
|
|
|
MWM_FUNC_MAXIMIZE | MWM_FUNC_RESIZE,
|
|
|
|
.old_gravity = NorthWestGravity,
|
|
|
|
.fs_layer = WIN_LAYER_ABOVE_DOCK,
|
|
|
|
};
|
|
|
|
vo->x11 = x11;
|
2012-08-03 03:55:02 +00:00
|
|
|
|
2010-07-01 19:52:18 +00:00
|
|
|
if (vo_rootwin)
|
|
|
|
WinID = 0; // use root window
|
2001-03-03 21:47:37 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
XSetErrorHandler(x11_errorhandler);
|
2002-02-22 19:36:21 +00:00
|
|
|
|
2012-11-15 14:38:02 +00:00
|
|
|
dispName = XDisplayName(NULL);
|
2002-02-22 19:36:21 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "X11 opening display: %s\n", dispName);
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
x11->display = XOpenDisplay(dispName);
|
|
|
|
if (!x11->display)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR,
|
|
|
|
"vo: couldn't open the X11 display (%s)!\n", dispName);
|
2012-08-03 03:55:02 +00:00
|
|
|
talloc_free(x11);
|
|
|
|
vo->x11 = NULL;
|
2004-06-14 04:53:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-21 01:59:00 +00:00
|
|
|
x11->screen = DefaultScreen(x11->display); // screen ID
|
|
|
|
x11->rootwin = RootWindow(x11->display, x11->screen); // root window ID
|
2001-05-31 22:32:58 +00:00
|
|
|
|
2012-01-14 13:09:44 +00:00
|
|
|
x11->xim = XOpenIM(x11->display, NULL, NULL, NULL);
|
|
|
|
|
2008-04-20 23:50:40 +00:00
|
|
|
init_atoms(vo->x11);
|
2001-10-10 01:48:54 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
int clock;
|
2013-01-26 21:37:47 +00:00
|
|
|
XF86VidModeModeLine modeline;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-21 01:59:00 +00:00
|
|
|
XF86VidModeGetModeLine(x11->display, x11->screen, &clock, &modeline);
|
2008-04-20 23:18:28 +00:00
|
|
|
if (!opts->vo_screenwidth)
|
|
|
|
opts->vo_screenwidth = modeline.hdisplay;
|
|
|
|
if (!opts->vo_screenheight)
|
|
|
|
opts->vo_screenheight = modeline.vdisplay;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2001-10-10 01:48:54 +00:00
|
|
|
#endif
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-04-20 23:18:28 +00:00
|
|
|
if (!opts->vo_screenwidth)
|
2008-04-21 01:59:00 +00:00
|
|
|
opts->vo_screenwidth = DisplayWidth(x11->display, x11->screen);
|
2008-04-20 23:18:28 +00:00
|
|
|
if (!opts->vo_screenheight)
|
2008-04-21 01:59:00 +00:00
|
|
|
opts->vo_screenheight = DisplayHeight(x11->display, x11->screen);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
2001-05-31 22:32:58 +00:00
|
|
|
// XCloseDisplay( mDisplay );
|
2001-08-06 00:22:44 +00:00
|
|
|
/* slightly improved local display detection AST */
|
2004-06-14 04:53:03 +00:00
|
|
|
if (strncmp(dispName, "unix:", 5) == 0)
|
|
|
|
dispName += 4;
|
|
|
|
else if (strncmp(dispName, "localhost:", 10) == 0)
|
|
|
|
dispName += 9;
|
|
|
|
if (*dispName == ':' && atoi(dispName + 1) < 10)
|
2008-04-21 01:59:00 +00:00
|
|
|
x11->display_is_local = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
else
|
2008-04-21 01:59:00 +00:00
|
|
|
x11->display_is_local = 0;
|
2013-01-26 21:37:47 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo: X11 running at %dx%d (\"%s\" => %s display)\n",
|
|
|
|
opts->vo_screenwidth, opts->vo_screenheight, dispName,
|
|
|
|
x11->display_is_local ? "local" : "remote");
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
x11->wm_type = vo_wm_detect(vo);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->fs_type = vo_x11_get_fs_type(vo);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
fstype_dump(x11->fs_type);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (opts->vo_stop_screensaver)
|
|
|
|
saver_off(x11);
|
2001-03-03 21:47:37 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
return 1;
|
2002-05-08 16:41:44 +00:00
|
|
|
}
|
2002-01-31 11:04:41 +00:00
|
|
|
|
2010-04-23 10:22:44 +00:00
|
|
|
static const struct mp_keymap keymap[] = {
|
2008-12-20 11:12:45 +00:00
|
|
|
// special keys
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_Pause, KEY_PAUSE}, {XK_Escape, KEY_ESC}, {XK_BackSpace, KEY_BS},
|
|
|
|
{XK_Tab, KEY_TAB}, {XK_Return, KEY_ENTER},
|
2012-01-13 09:09:40 +00:00
|
|
|
{XK_Menu, KEY_MENU}, {XK_Print, KEY_PRINT},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// cursor keys
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_Left, KEY_LEFT}, {XK_Right, KEY_RIGHT}, {XK_Up, KEY_UP}, {XK_Down, KEY_DOWN},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// navigation block
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_Insert, KEY_INSERT}, {XK_Delete, KEY_DELETE}, {XK_Home, KEY_HOME}, {XK_End, KEY_END},
|
|
|
|
{XK_Page_Up, KEY_PAGE_UP}, {XK_Page_Down, KEY_PAGE_DOWN},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// F-keys
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_F1, KEY_F+1}, {XK_F2, KEY_F+2}, {XK_F3, KEY_F+3}, {XK_F4, KEY_F+4},
|
|
|
|
{XK_F5, KEY_F+5}, {XK_F6, KEY_F+6}, {XK_F7, KEY_F+7}, {XK_F8, KEY_F+8},
|
|
|
|
{XK_F9, KEY_F+9}, {XK_F10, KEY_F+10}, {XK_F11, KEY_F+11}, {XK_F12, KEY_F+12},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// numpad independent of numlock
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_KP_Subtract, '-'}, {XK_KP_Add, '+'}, {XK_KP_Multiply, '*'}, {XK_KP_Divide, '/'},
|
|
|
|
{XK_KP_Enter, KEY_KPENTER},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// numpad with numlock
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_KP_0, KEY_KP0}, {XK_KP_1, KEY_KP1}, {XK_KP_2, KEY_KP2},
|
|
|
|
{XK_KP_3, KEY_KP3}, {XK_KP_4, KEY_KP4}, {XK_KP_5, KEY_KP5},
|
|
|
|
{XK_KP_6, KEY_KP6}, {XK_KP_7, KEY_KP7}, {XK_KP_8, KEY_KP8},
|
|
|
|
{XK_KP_9, KEY_KP9}, {XK_KP_Decimal, KEY_KPDEC},
|
|
|
|
{XK_KP_Separator, KEY_KPDEC},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
|
|
|
// numpad without numlock
|
2012-01-13 08:25:12 +00:00
|
|
|
{XK_KP_Insert, KEY_KPINS}, {XK_KP_End, KEY_KP1}, {XK_KP_Down, KEY_KP2},
|
|
|
|
{XK_KP_Page_Down, KEY_KP3}, {XK_KP_Left, KEY_KP4}, {XK_KP_Begin, KEY_KP5},
|
|
|
|
{XK_KP_Right, KEY_KP6}, {XK_KP_Home, KEY_KP7}, {XK_KP_Up, KEY_KP8},
|
|
|
|
{XK_KP_Page_Up, KEY_KP9}, {XK_KP_Delete, KEY_KPDEL},
|
2008-12-20 11:12:45 +00:00
|
|
|
|
2012-01-14 13:09:44 +00:00
|
|
|
#ifdef XF86XK_AudioPause
|
|
|
|
{XF86XK_MenuKB, KEY_MENU},
|
|
|
|
{XF86XK_AudioPlay, KEY_PLAY}, {XF86XK_AudioPause, KEY_PAUSE}, {XF86XK_AudioStop, KEY_STOP},
|
|
|
|
{XF86XK_AudioPrev, KEY_PREV}, {XF86XK_AudioNext, KEY_NEXT},
|
|
|
|
{XF86XK_AudioMute, KEY_MUTE}, {XF86XK_AudioLowerVolume, KEY_VOLUME_DOWN}, {XF86XK_AudioRaiseVolume, KEY_VOLUME_UP},
|
|
|
|
#endif
|
2008-12-20 11:12:45 +00:00
|
|
|
|
2009-07-06 23:26:13 +00:00
|
|
|
{0, 0}
|
2008-12-20 11:12:45 +00:00
|
|
|
};
|
|
|
|
|
2012-01-14 13:09:44 +00:00
|
|
|
static int vo_x11_lookupkey(int key)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-12-20 10:25:13 +00:00
|
|
|
static const char *passthrough_keys = " -+*/<>`~!@#$%^&()_{}:;\"\',.?\\|=[]";
|
2008-12-20 11:12:45 +00:00
|
|
|
int mpkey = 0;
|
2008-12-20 10:25:13 +00:00
|
|
|
if ((key >= 'a' && key <= 'z') ||
|
|
|
|
(key >= 'A' && key <= 'Z') ||
|
|
|
|
(key >= '0' && key <= '9') ||
|
|
|
|
(key > 0 && key < 256 && strchr(passthrough_keys, key)))
|
2008-12-20 11:12:45 +00:00
|
|
|
mpkey = key;
|
2008-12-20 10:25:13 +00:00
|
|
|
|
2008-12-20 11:52:11 +00:00
|
|
|
if (!mpkey)
|
2008-12-21 04:11:51 +00:00
|
|
|
mpkey = lookup_keymap_table(keymap, key);
|
2001-04-12 00:05:41 +00:00
|
|
|
|
2012-01-14 13:09:44 +00:00
|
|
|
return mpkey;
|
2001-03-03 21:47:37 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_decoration(struct vo *vo, int d)
|
2001-03-03 21:47:37 +00:00
|
|
|
{
|
2008-04-21 01:09:26 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
Atom mtype;
|
|
|
|
int mformat;
|
|
|
|
unsigned long mn, mb;
|
2013-01-26 21:37:47 +00:00
|
|
|
Atom vo_MotifHints;
|
|
|
|
MotifWmHints vo_MotifWmHints;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
if (!WinID)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vo_fsmode & 8)
|
2002-03-08 20:14:08 +00:00
|
|
|
{
|
2008-04-21 01:09:26 +00:00
|
|
|
XSetTransientForHint(x11->display, x11->window,
|
2008-04-21 01:59:00 +00:00
|
|
|
RootWindow(x11->display, x11->screen));
|
2002-03-08 20:14:08 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-21 01:09:26 +00:00
|
|
|
vo_MotifHints = XInternAtom(x11->display, "_MOTIF_WM_HINTS", 0);
|
2004-06-14 04:53:03 +00:00
|
|
|
if (vo_MotifHints != None)
|
|
|
|
{
|
|
|
|
if (!d)
|
|
|
|
{
|
|
|
|
MotifWmHints *mhints = NULL;
|
|
|
|
|
2008-04-21 01:09:26 +00:00
|
|
|
XGetWindowProperty(x11->display, x11->window,
|
|
|
|
vo_MotifHints, 0, 20, False,
|
2004-06-14 04:53:03 +00:00
|
|
|
vo_MotifHints, &mtype, &mformat, &mn,
|
|
|
|
&mb, (unsigned char **) &mhints);
|
|
|
|
if (mhints)
|
|
|
|
{
|
|
|
|
if (mhints->flags & MWM_HINTS_DECORATIONS)
|
2008-04-21 01:09:26 +00:00
|
|
|
x11->olddecor = mhints->decorations;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (mhints->flags & MWM_HINTS_FUNCTIONS)
|
2008-04-21 01:09:26 +00:00
|
|
|
x11->oldfuncs = mhints->functions;
|
2004-06-14 04:53:03 +00:00
|
|
|
XFree(mhints);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&vo_MotifWmHints, 0, sizeof(MotifWmHints));
|
|
|
|
vo_MotifWmHints.flags =
|
|
|
|
MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
|
|
|
|
if (d)
|
|
|
|
{
|
2008-04-21 01:09:26 +00:00
|
|
|
vo_MotifWmHints.functions = x11->oldfuncs;
|
|
|
|
d = x11->olddecor;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2002-03-08 20:14:08 +00:00
|
|
|
#if 0
|
2004-06-14 04:53:03 +00:00
|
|
|
vo_MotifWmHints.decorations =
|
|
|
|
d | ((vo_fsmode & 2) ? 0 : MWM_DECOR_MENU);
|
2002-03-08 20:14:08 +00:00
|
|
|
#else
|
2004-06-14 04:53:03 +00:00
|
|
|
vo_MotifWmHints.decorations =
|
|
|
|
d | ((vo_fsmode & 2) ? MWM_DECOR_MENU : 0);
|
2002-03-08 20:14:08 +00:00
|
|
|
#endif
|
2008-04-21 01:09:26 +00:00
|
|
|
XChangeProperty(x11->display, x11->window, vo_MotifHints,
|
|
|
|
vo_MotifHints, 32,
|
2004-06-14 04:53:03 +00:00
|
|
|
PropModeReplace,
|
|
|
|
(unsigned char *) &vo_MotifWmHints,
|
|
|
|
(vo_fsmode & 4) ? 4 : 5);
|
|
|
|
}
|
2001-03-03 21:47:37 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_classhint(struct vo *vo, Window window, const char *name)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2010-11-04 03:41:11 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2008-04-20 23:50:40 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
XClassHint wmClass;
|
|
|
|
pid_t pid = getpid();
|
|
|
|
|
2011-03-07 20:50:45 +00:00
|
|
|
wmClass.res_name = opts->vo_winname ? opts->vo_winname : (char *)name;
|
2012-10-11 00:04:08 +00:00
|
|
|
wmClass.res_class = "mpv";
|
2008-04-20 23:50:40 +00:00
|
|
|
XSetClassHint(x11->display, window, &wmClass);
|
|
|
|
XChangeProperty(x11->display, window, x11->XA_NET_WM_PID, XA_CARDINAL,
|
|
|
|
32, PropModeReplace, (unsigned char *) &pid, 1);
|
2001-06-17 01:22:09 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
void vo_x11_uninit(struct vo *vo)
|
2002-01-31 11:15:54 +00:00
|
|
|
{
|
2008-04-21 00:14:37 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2013-01-26 21:37:47 +00:00
|
|
|
assert(x11);
|
|
|
|
|
2013-01-27 06:21:10 +00:00
|
|
|
vo_x11_vm_close(vo);
|
2013-01-26 21:37:47 +00:00
|
|
|
saver_on(x11);
|
2008-04-21 00:14:37 +00:00
|
|
|
if (x11->window != None)
|
|
|
|
vo_showcursor(x11->display, x11->window);
|
2002-02-17 12:34:29 +00:00
|
|
|
|
2010-06-14 19:17:38 +00:00
|
|
|
if (x11->f_gc != None)
|
2008-04-21 01:19:43 +00:00
|
|
|
XFreeGC(vo->x11->display, x11->f_gc);
|
2013-01-26 21:37:47 +00:00
|
|
|
if (x11->vo_gc != None)
|
|
|
|
XFreeGC(vo->x11->display, x11->vo_gc);
|
|
|
|
if (x11->window != None) {
|
|
|
|
XClearWindow(x11->display, x11->window);
|
|
|
|
if (WinID < 0) {
|
|
|
|
XEvent xev;
|
|
|
|
|
|
|
|
XUnmapWindow(x11->display, x11->window);
|
|
|
|
XSelectInput(x11->display, x11->window, StructureNotifyMask);
|
|
|
|
XDestroyWindow(x11->display, x11->window);
|
|
|
|
do {
|
|
|
|
XNextEvent(x11->display, &xev);
|
|
|
|
} while (xev.type != DestroyNotify ||
|
|
|
|
xev.xdestroywindow.event != x11->window);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2013-01-26 21:37:47 +00:00
|
|
|
}
|
|
|
|
if (x11->xic)
|
|
|
|
XDestroyIC(x11->xic);
|
2013-01-27 11:01:08 +00:00
|
|
|
if (x11->colormap != None)
|
|
|
|
XFreeColormap(vo->x11->display, x11->colormap);
|
2013-01-26 21:37:47 +00:00
|
|
|
vo_fs = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "vo: uninit ...\n");
|
|
|
|
if (x11->xim)
|
|
|
|
XCloseIM(x11->xim);
|
|
|
|
XSetErrorHandler(NULL);
|
|
|
|
XCloseDisplay(x11->display);
|
2012-01-14 13:09:44 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
talloc_free(x11);
|
2012-08-03 03:55:02 +00:00
|
|
|
vo->x11 = NULL;
|
2002-01-31 11:15:54 +00:00
|
|
|
}
|
|
|
|
|
2010-07-01 19:48:00 +00:00
|
|
|
static int check_resize(struct vo *vo)
|
|
|
|
{
|
|
|
|
int old_w = vo->dwidth, old_h = vo->dheight;
|
2010-10-09 11:17:28 +00:00
|
|
|
int old_x = vo->dx, old_y = vo->dy;
|
|
|
|
int rc = 0;
|
2011-02-03 19:49:12 +00:00
|
|
|
vo_x11_update_geometry(vo, true);
|
2010-07-01 19:48:00 +00:00
|
|
|
if (vo->dwidth != old_w || vo->dheight != old_h)
|
2010-10-09 11:17:28 +00:00
|
|
|
rc |= VO_EVENT_RESIZE;
|
|
|
|
if (vo->dx != old_x || vo->dy != old_y)
|
|
|
|
rc |= VO_EVENT_MOVE;
|
|
|
|
return rc;
|
2010-07-01 19:48:00 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
int vo_x11_check_events(struct vo *vo)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-04-20 23:50:40 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2011-12-08 10:17:59 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2008-04-20 06:34:27 +00:00
|
|
|
Display *display = vo->x11->display;
|
2004-06-14 04:53:03 +00:00
|
|
|
int ret = 0;
|
|
|
|
XEvent Event;
|
2002-04-16 17:41:29 +00:00
|
|
|
|
2011-12-08 10:17:59 +00:00
|
|
|
if (x11->mouse_waiting_hide && opts->cursor_autohide_delay != -1 &&
|
|
|
|
(GetTimerMS() - x11->mouse_timer >= opts->cursor_autohide_delay)) {
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_hidecursor(display, x11->window);
|
2008-04-21 01:25:10 +00:00
|
|
|
x11->mouse_waiting_hide = 0;
|
2006-04-25 21:36:02 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2010-07-01 19:48:00 +00:00
|
|
|
if (WinID > 0)
|
|
|
|
ret |= check_resize(vo);
|
2008-04-20 06:34:27 +00:00
|
|
|
while (XPending(display))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-04-20 06:34:27 +00:00
|
|
|
XNextEvent(display, &Event);
|
2002-05-14 23:44:35 +00:00
|
|
|
// printf("\rEvent.type=%X \n",Event.type);
|
2004-06-14 04:53:03 +00:00
|
|
|
switch (Event.type)
|
|
|
|
{
|
|
|
|
case Expose:
|
|
|
|
ret |= VO_EVENT_EXPOSE;
|
|
|
|
break;
|
|
|
|
case ConfigureNotify:
|
2008-04-21 00:14:37 +00:00
|
|
|
if (x11->window == None)
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
2010-07-01 19:48:00 +00:00
|
|
|
ret |= check_resize(vo);
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
|
|
|
case KeyPress:
|
|
|
|
{
|
2012-01-14 13:09:44 +00:00
|
|
|
char buf[100];
|
|
|
|
KeySym keySym = 0;
|
2010-12-19 10:12:20 +00:00
|
|
|
int modifiers = 0;
|
|
|
|
if (Event.xkey.state & ShiftMask)
|
|
|
|
modifiers |= KEY_MODIFIER_SHIFT;
|
|
|
|
if (Event.xkey.state & ControlMask)
|
|
|
|
modifiers |= KEY_MODIFIER_CTRL;
|
|
|
|
if (Event.xkey.state & Mod1Mask)
|
|
|
|
modifiers |= KEY_MODIFIER_ALT;
|
|
|
|
if (Event.xkey.state & Mod4Mask)
|
|
|
|
modifiers |= KEY_MODIFIER_META;
|
2012-01-14 13:09:44 +00:00
|
|
|
if (x11->xic) {
|
|
|
|
Status status;
|
|
|
|
int len = Xutf8LookupString(x11->xic, &Event.xkey, buf,
|
|
|
|
sizeof(buf), &keySym,
|
|
|
|
&status);
|
|
|
|
int mpkey = vo_x11_lookupkey(keySym);
|
|
|
|
if (mpkey) {
|
|
|
|
mplayer_put_key(vo->key_fifo, mpkey | modifiers);
|
|
|
|
} else if (status == XLookupChars
|
|
|
|
|| status == XLookupBoth)
|
|
|
|
{
|
|
|
|
struct bstr t = { buf, len };
|
|
|
|
mplayer_put_key_utf8(vo->key_fifo, modifiers, t);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
XLookupString(&Event.xkey, buf, sizeof(buf), &keySym,
|
|
|
|
&x11->compose_status);
|
|
|
|
int mpkey = vo_x11_lookupkey(keySym);
|
|
|
|
if (mpkey)
|
|
|
|
mplayer_put_key(vo->key_fifo, mpkey | modifiers);
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
ret |= VO_EVENT_KEYPRESS;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MotionNotify:
|
2010-04-26 16:22:56 +00:00
|
|
|
vo_mouse_movement(vo, Event.xmotion.x, Event.xmotion.y);
|
2006-09-16 15:13:41 +00:00
|
|
|
|
2011-12-08 10:17:59 +00:00
|
|
|
if (opts->cursor_autohide_delay > -2) {
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_showcursor(display, x11->window);
|
2008-04-21 01:25:10 +00:00
|
|
|
x11->mouse_waiting_hide = 1;
|
|
|
|
x11->mouse_timer = GetTimerMS();
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ButtonPress:
|
2011-12-08 10:17:59 +00:00
|
|
|
if (opts->cursor_autohide_delay > -2) {
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_showcursor(display, x11->window);
|
2008-04-21 01:25:10 +00:00
|
|
|
x11->mouse_waiting_hide = 1;
|
|
|
|
x11->mouse_timer = GetTimerMS();
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2008-04-29 12:12:19 +00:00
|
|
|
mplayer_put_key(vo->key_fifo,
|
|
|
|
(MOUSE_BTN0 + Event.xbutton.button - 1)
|
|
|
|
| MP_KEY_DOWN);
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
|
|
|
case ButtonRelease:
|
2011-12-08 10:17:59 +00:00
|
|
|
if (opts->cursor_autohide_delay > -2) {
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_showcursor(display, x11->window);
|
2008-04-21 01:25:10 +00:00
|
|
|
x11->mouse_waiting_hide = 1;
|
|
|
|
x11->mouse_timer = GetTimerMS();
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2008-04-29 12:12:19 +00:00
|
|
|
mplayer_put_key(vo->key_fifo,
|
|
|
|
MOUSE_BTN0 + Event.xbutton.button - 1);
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
|
|
|
case PropertyNotify:
|
|
|
|
{
|
|
|
|
char *name =
|
2008-04-20 06:34:27 +00:00
|
|
|
XGetAtomName(display, Event.xproperty.atom);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
if (!name)
|
|
|
|
break;
|
|
|
|
|
2002-05-11 17:21:32 +00:00
|
|
|
// fprintf(stderr,"[ws] PropertyNotify ( 0x%x ) %s ( 0x%x )\n",vo_window,name,Event.xproperty.atom );
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
XFree(name);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MapNotify:
|
2008-04-21 01:37:46 +00:00
|
|
|
x11->vo_hint.win_gravity = x11->old_gravity;
|
2008-04-21 01:19:43 +00:00
|
|
|
XSetWMNormalHints(display, x11->window, &x11->vo_hint);
|
2008-04-21 01:50:29 +00:00
|
|
|
x11->fs_flip = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
2010-05-14 18:00:04 +00:00
|
|
|
case DestroyNotify:
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN, "Our window was destroyed, exiting\n");
|
2010-05-30 12:42:42 +00:00
|
|
|
mplayer_put_key(vo->key_fifo, KEY_CLOSE_WIN);
|
2010-05-14 18:00:04 +00:00
|
|
|
break;
|
2006-04-19 15:58:10 +00:00
|
|
|
case ClientMessage:
|
2008-04-20 23:50:40 +00:00
|
|
|
if (Event.xclient.message_type == x11->XAWM_PROTOCOLS &&
|
|
|
|
Event.xclient.data.l[0] == x11->XAWM_DELETE_WINDOW)
|
2008-04-29 12:12:19 +00:00
|
|
|
mplayer_put_key(vo->key_fifo, KEY_CLOSE_WIN);
|
2006-04-19 15:58:10 +00:00
|
|
|
break;
|
2013-01-02 11:55:52 +00:00
|
|
|
default:
|
|
|
|
if (Event.type == x11->ShmCompletionEvent)
|
|
|
|
if (x11->ShmCompletionWaitCount > 0)
|
|
|
|
x11->ShmCompletionWaitCount--;
|
|
|
|
break;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
2001-03-03 21:47:37 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_sizehint(struct vo *vo, int x, int y, int width, int height,
|
|
|
|
int max)
|
2002-03-08 20:14:08 +00:00
|
|
|
{
|
2008-04-21 00:14:37 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (vo_keepaspect)
|
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags |= PAspect;
|
|
|
|
x11->vo_hint.min_aspect.x = width;
|
|
|
|
x11->vo_hint.min_aspect.y = height;
|
|
|
|
x11->vo_hint.max_aspect.x = width;
|
|
|
|
x11->vo_hint.max_aspect.y = height;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags |= PPosition | PSize;
|
|
|
|
x11->vo_hint.x = x;
|
|
|
|
x11->vo_hint.y = y;
|
|
|
|
x11->vo_hint.width = width;
|
|
|
|
x11->vo_hint.height = height;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (max)
|
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags |= PMaxSize;
|
|
|
|
x11->vo_hint.max_width = width;
|
|
|
|
x11->vo_hint.max_height = height;
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.max_width = 0;
|
|
|
|
x11->vo_hint.max_height = 0;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
libvo, libao: remove useless video and audio output drivers
Some of these have only limited use, and some of these have no use at
all. Remove them. They make maintainance harder and nobody needs them.
It's possible that many of the removed drivers were very useful a dozen
of years ago, but now it's 2012.
Note that some of these could be added back, in case they were more
useful than I thought. But right now, they are just a burden.
Reason for removal for each module:
vo_3dfx, vo_dfbmga, vo_dxr3, vo_ivtv, vo_mga, vo_s3fb,
vo_tdfxfb, vo_xmga, vo_tdfx_vid:
All of these are for very specific and outdated hardware. Some
of them require non-standard kernel drivers or do direct HW
access.
vo_dga: the most crappy and ancient way to get fast output on X.
vo_aa: there's vo_caca for the same purpose.
vo_ggi: this never lived, and is entirely useless.
vo_mpegpes: for DVB cards, I can't test this and it's crappy.
vo_fbdev, vo_fbdev2: there's vo_directfb2
vo_bl: what is this even? But it's neither important, nor alive.
vo_svga, vo_vesa: you want to use this? You can't be serious.
vo_wii: I can't test this, and who the hell uses this?
vo_xvr100: some Sun thing.
vo_xover: only useful in connection with xvr100.
ao_nas: still alive, but I doubt it has any meaning today.
ao_sun: Sun.
ao_win32: use ao_dsound or ao_portaudio instead.
ao_ivtv: removed along vo_ivtv.
Also get rid of anything SDL related. SDL 1.x is total crap for video
output, and will be replaced with SDL 2.x soon (perhaps), so if you
want to use SDL, write output drivers for SDL 2.x.
Additionally, I accidentally damaged Sun support, which made me
completely remove Sun/Solaris support. Nobody cares about this anyway.
Some left overs from previous commits removing modules were cleaned up.
2012-07-28 18:20:17 +00:00
|
|
|
// Set minimum height/width to 4 to avoid off-by-one errors.
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags |= PMinSize;
|
|
|
|
x11->vo_hint.min_width = x11->vo_hint.min_height = 4;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-12-05 19:01:49 +00:00
|
|
|
// Set the base size. A window manager might display the window
|
|
|
|
// size to the user relative to this.
|
|
|
|
// Setting these to width/height might be nice, but e.g. fluxbox can't handle it.
|
2008-12-06 00:16:51 +00:00
|
|
|
x11->vo_hint.flags |= PBaseSize;
|
|
|
|
x11->vo_hint.base_width = 0 /*width*/;
|
|
|
|
x11->vo_hint.base_height = 0 /*height*/;
|
2008-12-05 19:01:49 +00:00
|
|
|
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->vo_hint.flags |= PWinGravity;
|
|
|
|
x11->vo_hint.win_gravity = StaticGravity;
|
|
|
|
XSetWMNormalHints(x11->display, x11->window, &x11->vo_hint);
|
2002-03-08 20:14:08 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
/**
|
|
|
|
* \brief sets the size and position of the non-fullscreen window.
|
|
|
|
*/
|
|
|
|
static void vo_x11_nofs_sizepos(struct vo *vo, int x, int y,
|
|
|
|
int width, int height)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
if (width == x11->last_video_width && height == x11->last_video_height) {
|
|
|
|
if (!vo->opts->force_window_position && !x11->size_changed_during_fs)
|
|
|
|
return;
|
|
|
|
} else if (vo_fs)
|
|
|
|
x11->size_changed_during_fs = true;
|
|
|
|
x11->last_video_height = height;
|
|
|
|
x11->last_video_width = width;
|
|
|
|
vo_x11_sizehint(vo, x, y, width, height, 0);
|
|
|
|
if (vo_fs) {
|
|
|
|
x11->vo_old_x = x;
|
|
|
|
x11->vo_old_y = y;
|
|
|
|
x11->vo_old_width = width;
|
|
|
|
x11->vo_old_height = height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
vo->dwidth = width;
|
|
|
|
vo->dheight = height;
|
|
|
|
if (vo->opts->force_window_position)
|
|
|
|
XMoveResizeWindow(vo->x11->display, vo->x11->window, x, y, width,
|
|
|
|
height);
|
|
|
|
else
|
|
|
|
XResizeWindow(vo->x11->display, vo->x11->window, width, height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-20 23:50:40 +00:00
|
|
|
static int vo_x11_get_gnome_layer(struct vo_x11_state *x11, Window win)
|
2003-01-09 21:23:54 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
Atom type;
|
|
|
|
int format;
|
|
|
|
unsigned long nitems;
|
|
|
|
unsigned long bytesafter;
|
|
|
|
unsigned short *args = NULL;
|
|
|
|
|
2008-04-20 23:50:40 +00:00
|
|
|
if (XGetWindowProperty(x11->display, win, x11->XA_WIN_LAYER, 0, 16384,
|
2004-06-14 04:53:03 +00:00
|
|
|
False, AnyPropertyType, &type, &format, &nitems,
|
|
|
|
&bytesafter,
|
|
|
|
(unsigned char **) &args) == Success
|
|
|
|
&& nitems > 0 && args)
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "[x11] original window layer is %d.\n",
|
|
|
|
*args);
|
|
|
|
return *args;
|
|
|
|
}
|
|
|
|
return WIN_LAYER_NORMAL;
|
2003-01-09 21:23:54 +00:00
|
|
|
}
|
|
|
|
|
2012-01-25 01:01:22 +00:00
|
|
|
// set a X text property that expects a UTF8_STRING type
|
|
|
|
static void vo_x11_set_property_utf8(struct vo *vo, Atom name, const char *t)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
|
|
|
|
XChangeProperty(x11->display, x11->window, name, x11->XAUTF8_STRING, 8,
|
|
|
|
PropModeReplace, t, strlen(t));
|
|
|
|
}
|
|
|
|
|
2011-12-26 16:15:11 +00:00
|
|
|
// set a X text property that expects a STRING or COMPOUND_TEXT type
|
2011-12-06 17:48:31 +00:00
|
|
|
static void vo_x11_set_property_string(struct vo *vo, Atom name, const char *t)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
XTextProperty prop = {0};
|
|
|
|
|
2011-12-26 16:15:11 +00:00
|
|
|
if (Xutf8TextListToTextProperty(x11->display, (char **)&t, 1,
|
|
|
|
XStdICCTextStyle, &prop) == Success)
|
|
|
|
{
|
2011-12-06 17:48:31 +00:00
|
|
|
XSetTextProperty(x11->display, x11->window, &prop, name);
|
2012-01-25 01:01:22 +00:00
|
|
|
} else {
|
|
|
|
// Strictly speaking this violates the ICCCM, but there's no way we
|
|
|
|
// can do this correctly.
|
|
|
|
vo_x11_set_property_utf8(vo, name, t);
|
2011-12-26 16:15:11 +00:00
|
|
|
}
|
2011-12-06 17:48:31 +00:00
|
|
|
|
2012-01-25 01:01:22 +00:00
|
|
|
if (prop.value)
|
|
|
|
XFree(prop.value);
|
2011-12-06 17:48:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vo_x11_update_window_title(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
|
|
|
|
const char *title = vo_get_window_title(vo);
|
|
|
|
vo_x11_set_property_string(vo, XA_WM_NAME, title);
|
|
|
|
vo_x11_set_property_string(vo, XA_WM_ICON_NAME, title);
|
|
|
|
vo_x11_set_property_utf8(vo, x11->XA_NET_WM_NAME, title);
|
|
|
|
vo_x11_set_property_utf8(vo, x11->XA_NET_WM_ICON_NAME, title);
|
|
|
|
}
|
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
static void setup_window_params(struct vo_x11_state *x11, XVisualInfo *vis,
|
|
|
|
unsigned long *mask, XSetWindowAttributes *att)
|
2003-08-31 22:27:10 +00:00
|
|
|
{
|
2013-01-27 11:01:08 +00:00
|
|
|
vo_x11_create_colormap(x11, vis);
|
|
|
|
|
|
|
|
*mask = CWBorderPixel | CWColormap;
|
|
|
|
att->border_pixel = 0;
|
|
|
|
att->colormap = x11->colormap;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void find_default_visual(struct vo_x11_state *x11, XVisualInfo *vis)
|
|
|
|
{
|
|
|
|
Display *display = x11->display;
|
|
|
|
XWindowAttributes attribs;
|
|
|
|
XGetWindowAttributes(display, DefaultRootWindow(display), &attribs);
|
|
|
|
XMatchVisualInfo(display, x11->screen, attribs.depth, TrueColor, vis);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Window vo_x11_create_smooth_window(struct vo_x11_state *x11,
|
|
|
|
XVisualInfo *vis, int x, int y,
|
|
|
|
unsigned int width, unsigned int height)
|
|
|
|
{
|
|
|
|
unsigned long xswamask;
|
2004-06-14 04:53:03 +00:00
|
|
|
XSetWindowAttributes xswa;
|
|
|
|
Window ret_win;
|
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
setup_window_params(x11, vis, &xswamask, &xswa);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
ret_win =
|
2013-01-27 11:01:08 +00:00
|
|
|
XCreateWindow(x11->display, x11->rootwin, x, y, width, height, 0,
|
|
|
|
vis->depth, CopyFromParent, vis->visual, xswamask, &xswa);
|
2008-04-20 23:50:40 +00:00
|
|
|
XSetWMProtocols(x11->display, ret_win, &x11->XAWM_DELETE_WINDOW, 1);
|
2010-06-14 19:17:38 +00:00
|
|
|
if (x11->f_gc == None)
|
2008-04-21 01:19:43 +00:00
|
|
|
x11->f_gc = XCreateGC(x11->display, ret_win, 0, 0);
|
|
|
|
XSetForeground(x11->display, x11->f_gc, 0);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
return ret_win;
|
2003-08-31 22:27:10 +00:00
|
|
|
}
|
|
|
|
|
2007-06-27 10:26:13 +00:00
|
|
|
/**
|
|
|
|
* \brief create and setup a window suitable for display
|
2013-01-27 11:01:08 +00:00
|
|
|
* \param vis Visual to use for creating the window (NULL for default)
|
2007-06-27 10:26:13 +00:00
|
|
|
* \param x x position of window
|
|
|
|
* \param y y position of window
|
|
|
|
* \param width width of window
|
|
|
|
* \param height height of window
|
|
|
|
* \param flags flags for window creation.
|
|
|
|
* \param classname name to use for the classhint
|
|
|
|
*
|
|
|
|
* This also does the grunt-work like setting Window Manager hints etc.
|
|
|
|
* If vo_window is already set it just moves and resizes it.
|
|
|
|
*/
|
2008-04-19 04:45:16 +00:00
|
|
|
void vo_x11_create_vo_window(struct vo *vo, XVisualInfo *vis, int x, int y,
|
2007-06-27 10:26:13 +00:00
|
|
|
unsigned int width, unsigned int height, int flags,
|
2013-01-27 11:01:08 +00:00
|
|
|
const char *classname)
|
2007-06-27 10:26:13 +00:00
|
|
|
{
|
2008-04-19 04:45:16 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2008-04-20 23:50:40 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2008-04-20 06:34:27 +00:00
|
|
|
Display *mDisplay = vo->x11->display;
|
2013-01-23 09:56:11 +00:00
|
|
|
bool force_change_xy = opts->vo_geometry.xy_valid || xinerama_screen >= 0;
|
2013-01-27 11:01:08 +00:00
|
|
|
XVisualInfo vinfo_storage;
|
|
|
|
if (!vis) {
|
|
|
|
vis = &vinfo_storage;
|
|
|
|
find_default_visual(x11, vis);
|
|
|
|
}
|
2008-11-19 20:19:25 +00:00
|
|
|
if (WinID >= 0) {
|
2013-01-27 11:01:08 +00:00
|
|
|
unsigned long xswamask;
|
|
|
|
XSetWindowAttributes xswa;
|
2009-08-27 12:03:02 +00:00
|
|
|
vo_fs = flags & VOFLAG_FULLSCREEN;
|
2008-11-22 17:16:43 +00:00
|
|
|
x11->window = WinID ? (Window)WinID : x11->rootwin;
|
2013-01-27 11:01:08 +00:00
|
|
|
setup_window_params(x11, vis, &xswamask, &xswa);
|
|
|
|
XChangeWindowAttributes(mDisplay, x11->window, xswamask, &xswa);
|
2010-07-01 19:48:00 +00:00
|
|
|
if (WinID) {
|
|
|
|
// Expose events can only really be handled by us, so request them.
|
|
|
|
vo_x11_selectinput_witherr(mDisplay, x11->window, ExposureMask);
|
|
|
|
} else
|
|
|
|
// Do not capture events since it might break the parent application
|
|
|
|
// if it relies on events being forwarded to the parent of WinID.
|
|
|
|
// It also is consistent with the w32_common.c code.
|
|
|
|
vo_x11_selectinput_witherr(mDisplay, x11->window,
|
2008-11-19 20:19:25 +00:00
|
|
|
StructureNotifyMask | KeyPressMask | PointerMotionMask |
|
|
|
|
ButtonPressMask | ButtonReleaseMask | ExposureMask);
|
2010-07-02 19:59:02 +00:00
|
|
|
|
2011-02-03 19:49:12 +00:00
|
|
|
vo_x11_update_geometry(vo, true);
|
2008-11-19 20:19:25 +00:00
|
|
|
goto final;
|
|
|
|
}
|
2008-04-21 00:14:37 +00:00
|
|
|
if (x11->window == None) {
|
2007-06-27 10:26:13 +00:00
|
|
|
vo_fs = 0;
|
2008-04-20 20:29:28 +00:00
|
|
|
vo->dwidth = width;
|
|
|
|
vo->dheight = height;
|
2013-01-27 11:01:08 +00:00
|
|
|
x11->window = vo_x11_create_smooth_window(x11, vis, x, y, width, height);
|
2010-03-09 17:58:02 +00:00
|
|
|
x11->window_state = VOFLAG_HIDDEN;
|
2010-02-04 22:08:23 +00:00
|
|
|
}
|
|
|
|
if (flags & VOFLAG_HIDDEN)
|
|
|
|
goto final;
|
2010-03-09 17:58:02 +00:00
|
|
|
if (x11->window_state & VOFLAG_HIDDEN) {
|
2013-01-27 06:21:10 +00:00
|
|
|
if (flags & VOFLAG_MODESWITCHING)
|
|
|
|
vo_x11_vm_switch(vo);
|
2010-02-04 22:08:23 +00:00
|
|
|
XSizeHints hint;
|
2010-03-09 17:58:02 +00:00
|
|
|
x11->window_state &= ~VOFLAG_HIDDEN;
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_classhint(vo, x11->window, classname);
|
|
|
|
vo_hidecursor(mDisplay, x11->window);
|
|
|
|
XSelectInput(mDisplay, x11->window, StructureNotifyMask);
|
2007-06-27 10:26:13 +00:00
|
|
|
hint.x = x; hint.y = y;
|
|
|
|
hint.width = width; hint.height = height;
|
2010-05-30 19:14:18 +00:00
|
|
|
hint.flags = PSize;
|
2013-01-27 06:47:47 +00:00
|
|
|
if (force_change_xy || x11->vm_set)
|
2010-05-30 19:14:18 +00:00
|
|
|
hint.flags |= PPosition;
|
2011-12-06 17:48:31 +00:00
|
|
|
XSetWMNormalHints(mDisplay, x11->window, &hint);
|
2013-01-27 06:47:47 +00:00
|
|
|
if (!vo_border || x11->vm_set) vo_x11_decoration(vo, 0);
|
2007-06-27 10:26:13 +00:00
|
|
|
// map window
|
2012-01-14 13:09:44 +00:00
|
|
|
x11->xic = XCreateIC(x11->xim,
|
|
|
|
XNInputStyle, XIMPreeditNone | XIMStatusNone,
|
|
|
|
XNClientWindow, x11->window,
|
|
|
|
XNFocusWindow, x11->window,
|
|
|
|
NULL);
|
2008-04-21 00:14:37 +00:00
|
|
|
XSelectInput(mDisplay, x11->window, NoEventMask);
|
|
|
|
vo_x11_selectinput_witherr(mDisplay, x11->window,
|
2007-06-27 10:26:13 +00:00
|
|
|
StructureNotifyMask | KeyPressMask | PointerMotionMask |
|
|
|
|
ButtonPressMask | ButtonReleaseMask | ExposureMask);
|
2011-07-06 05:42:57 +00:00
|
|
|
XMapWindow(mDisplay, x11->window);
|
|
|
|
vo_x11_clearwindow(vo, x11->window);
|
2007-06-27 10:26:13 +00:00
|
|
|
}
|
2011-12-06 17:48:31 +00:00
|
|
|
vo_x11_update_window_title(vo);
|
2008-04-21 00:14:37 +00:00
|
|
|
if (opts->vo_ontop) vo_x11_setlayer(vo, x11->window, opts->vo_ontop);
|
2013-01-23 09:56:11 +00:00
|
|
|
vo_x11_update_geometry(vo, !force_change_xy);
|
2008-04-20 20:29:28 +00:00
|
|
|
vo_x11_nofs_sizepos(vo, vo->dx, vo->dy, width, height);
|
2007-06-27 10:26:13 +00:00
|
|
|
if (!!vo_fs != !!(flags & VOFLAG_FULLSCREEN))
|
2008-04-19 04:45:16 +00:00
|
|
|
vo_x11_fullscreen(vo);
|
2009-03-04 08:37:54 +00:00
|
|
|
else if (vo_fs) {
|
|
|
|
// if we are already in fullscreen do not switch back and forth, just
|
|
|
|
// set the size values right.
|
2009-03-06 23:04:41 +00:00
|
|
|
vo->dwidth = vo->opts->vo_screenwidth;
|
|
|
|
vo->dheight = vo->opts->vo_screenheight;
|
2009-03-04 08:37:54 +00:00
|
|
|
}
|
2013-01-27 06:21:10 +00:00
|
|
|
if (x11->vm_set) {
|
|
|
|
/* Grab the mouse pointer in our window */
|
|
|
|
if (vo_grabpointer) {
|
|
|
|
XGrabPointer(x11->display, x11->window, True, 0, GrabModeAsync,
|
|
|
|
GrabModeAsync, x11->window, None, CurrentTime);
|
|
|
|
}
|
|
|
|
XSetInputFocus(x11->display, x11->window, RevertToNone,
|
|
|
|
CurrentTime);
|
|
|
|
}
|
2008-11-19 20:19:25 +00:00
|
|
|
final:
|
2008-11-22 17:16:43 +00:00
|
|
|
if (x11->vo_gc != None)
|
|
|
|
XFreeGC(mDisplay, x11->vo_gc);
|
2011-05-29 23:05:57 +00:00
|
|
|
x11->vo_gc = XCreateGC(mDisplay, x11->window, 0, NULL);
|
|
|
|
|
2008-11-19 20:19:25 +00:00
|
|
|
XSync(mDisplay, False);
|
2010-12-14 19:58:47 +00:00
|
|
|
vo->event_fd = ConnectionNumber(x11->display);
|
2007-06-27 10:26:13 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-20 20:29:28 +00:00
|
|
|
void vo_x11_clearwindow_part(struct vo *vo, Window vo_window,
|
2011-07-06 05:24:20 +00:00
|
|
|
int img_width, int img_height)
|
2003-08-31 22:27:10 +00:00
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2008-04-20 20:29:28 +00:00
|
|
|
Display *mDisplay = vo->x11->display;
|
2004-06-14 04:53:03 +00:00
|
|
|
int u_dheight, u_dwidth, left_ov, left_ov2;
|
|
|
|
|
2010-06-14 19:17:38 +00:00
|
|
|
if (x11->f_gc == None)
|
2004-06-14 04:53:03 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-06 05:24:20 +00:00
|
|
|
u_dheight = vo->dheight;
|
|
|
|
u_dwidth = vo->dwidth;
|
2004-06-14 04:53:03 +00:00
|
|
|
if ((u_dheight <= img_height) && (u_dwidth <= img_width))
|
|
|
|
return;
|
|
|
|
|
|
|
|
left_ov = (u_dheight - img_height) / 2;
|
|
|
|
left_ov2 = (u_dwidth - img_width) / 2;
|
|
|
|
|
2008-04-21 01:19:43 +00:00
|
|
|
XFillRectangle(mDisplay, vo_window, x11->f_gc, 0, 0, u_dwidth, left_ov);
|
|
|
|
XFillRectangle(mDisplay, vo_window, x11->f_gc, 0, u_dheight - left_ov - 1,
|
2004-06-14 04:53:03 +00:00
|
|
|
u_dwidth, left_ov + 1);
|
|
|
|
|
|
|
|
if (u_dwidth > img_width)
|
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
XFillRectangle(mDisplay, vo_window, x11->f_gc, 0, left_ov, left_ov2,
|
2004-06-14 04:53:03 +00:00
|
|
|
img_height);
|
2008-04-21 01:19:43 +00:00
|
|
|
XFillRectangle(mDisplay, vo_window, x11->f_gc, u_dwidth - left_ov2 - 1,
|
2007-06-27 13:09:39 +00:00
|
|
|
left_ov, left_ov2 + 1, img_height);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
XFlush(mDisplay);
|
2003-08-31 22:27:10 +00:00
|
|
|
}
|
|
|
|
|
2008-04-20 23:18:28 +00:00
|
|
|
void vo_x11_clearwindow(struct vo *vo, Window vo_window)
|
2003-08-31 22:27:10 +00:00
|
|
|
{
|
2008-04-21 01:19:43 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2008-04-20 23:18:28 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2010-06-14 19:17:38 +00:00
|
|
|
if (x11->f_gc == None)
|
2004-06-14 04:53:03 +00:00
|
|
|
return;
|
2008-04-21 01:19:43 +00:00
|
|
|
XFillRectangle(x11->display, vo_window, x11->f_gc, 0, 0,
|
2008-04-20 23:18:28 +00:00
|
|
|
opts->vo_screenwidth, opts->vo_screenheight);
|
2004-06-14 04:53:03 +00:00
|
|
|
//
|
2008-04-21 01:19:43 +00:00
|
|
|
XFlush(x11->display);
|
2003-08-31 22:27:10 +00:00
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void vo_x11_setlayer(struct vo *vo, Window vo_window, int layer)
|
2002-05-06 15:05:07 +00:00
|
|
|
{
|
2008-04-20 23:50:40 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (WinID >= 0)
|
|
|
|
return;
|
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
if (x11->fs_type & vo_wm_LAYER)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
XClientMessageEvent xev;
|
|
|
|
|
2008-04-21 01:37:46 +00:00
|
|
|
if (!x11->orig_layer)
|
|
|
|
x11->orig_layer = vo_x11_get_gnome_layer(x11, vo_window);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
|
|
xev.type = ClientMessage;
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.display = x11->display;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.window = vo_window;
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.message_type = x11->XA_WIN_LAYER;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.format = 32;
|
2013-01-26 21:37:47 +00:00
|
|
|
// if not fullscreen, stay on default layer
|
|
|
|
xev.data.l[0] = layer ? x11->fs_layer : x11->orig_layer;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.data.l[1] = CurrentTime;
|
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
2006-01-12 20:04:36 +00:00
|
|
|
"[x11] Layered style stay on top (layer %ld).\n",
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.data.l[0]);
|
2008-04-21 01:59:00 +00:00
|
|
|
XSendEvent(x11->display, x11->rootwin, False, SubstructureNotifyMask,
|
2004-06-14 04:53:03 +00:00
|
|
|
(XEvent *) & xev);
|
2008-04-21 01:50:29 +00:00
|
|
|
} else if (x11->fs_type & vo_wm_NETWM)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
XClientMessageEvent xev;
|
|
|
|
char *state;
|
|
|
|
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
|
|
xev.type = ClientMessage;
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.message_type = x11->XA_NET_WM_STATE;
|
|
|
|
xev.display = x11->display;
|
2004-06-14 04:53:03 +00:00
|
|
|
xev.window = vo_window;
|
|
|
|
xev.format = 32;
|
|
|
|
xev.data.l[0] = layer;
|
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
if (x11->fs_type & vo_wm_STAYS_ON_TOP)
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.data.l[1] = x11->XA_NET_WM_STATE_STAYS_ON_TOP;
|
2008-04-21 01:50:29 +00:00
|
|
|
else if (x11->fs_type & vo_wm_ABOVE)
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.data.l[1] = x11->XA_NET_WM_STATE_ABOVE;
|
2008-04-21 01:50:29 +00:00
|
|
|
else if (x11->fs_type & vo_wm_FULLSCREEN)
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.data.l[1] = x11->XA_NET_WM_STATE_FULLSCREEN;
|
2008-04-21 01:50:29 +00:00
|
|
|
else if (x11->fs_type & vo_wm_BELOW)
|
2007-01-18 09:03:42 +00:00
|
|
|
// This is not fallback. We can safely assume that the situation
|
|
|
|
// where only NETWM_STATE_BELOW is supported doesn't exist.
|
2008-04-20 23:50:40 +00:00
|
|
|
xev.data.l[1] = x11->XA_NET_WM_STATE_BELOW;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-21 01:59:00 +00:00
|
|
|
XSendEvent(x11->display, x11->rootwin, False, SubstructureRedirectMask,
|
2004-06-14 04:53:03 +00:00
|
|
|
(XEvent *) & xev);
|
2008-04-20 23:50:40 +00:00
|
|
|
state = XGetAtomName(x11->display, xev.data.l[1]);
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
|
|
|
"[x11] NET style stay on top (layer %d). Using state %s.\n",
|
|
|
|
layer, state);
|
|
|
|
XFree(state);
|
|
|
|
}
|
2002-05-06 15:05:07 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static int vo_x11_get_fs_type(struct vo *vo)
|
2003-02-07 19:38:39 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
int type = x11->wm_type;
|
|
|
|
char **fstype_list = vo->opts->vo_fstype_list;
|
2004-06-14 04:53:03 +00:00
|
|
|
int i;
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (fstype_list)
|
2003-02-07 19:38:39 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
for (i = 0; fstype_list[i]; i++)
|
2003-02-07 19:38:39 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
int neg = 0;
|
2013-01-26 21:37:47 +00:00
|
|
|
char *arg = fstype_list[i];
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (fstype_list[i][0] == '-')
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
neg = 1;
|
2013-01-26 21:37:47 +00:00
|
|
|
arg = fstype_list[i] + 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strncmp(arg, "layer", 5))
|
|
|
|
{
|
|
|
|
if (!neg && (arg[5] == '='))
|
|
|
|
{
|
|
|
|
char *endptr = NULL;
|
2013-01-26 21:37:47 +00:00
|
|
|
int layer = strtol(fstype_list[i] + 6, &endptr, 10);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
if (endptr && *endptr == '\0' && layer >= 0
|
|
|
|
&& layer <= 15)
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->fs_layer = layer;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_LAYER;
|
|
|
|
else
|
|
|
|
type |= vo_wm_LAYER;
|
|
|
|
} else if (!strcmp(arg, "above"))
|
|
|
|
{
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_ABOVE;
|
|
|
|
else
|
|
|
|
type |= vo_wm_ABOVE;
|
|
|
|
} else if (!strcmp(arg, "fullscreen"))
|
|
|
|
{
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_FULLSCREEN;
|
|
|
|
else
|
|
|
|
type |= vo_wm_FULLSCREEN;
|
|
|
|
} else if (!strcmp(arg, "stays_on_top"))
|
|
|
|
{
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_STAYS_ON_TOP;
|
|
|
|
else
|
|
|
|
type |= vo_wm_STAYS_ON_TOP;
|
|
|
|
} else if (!strcmp(arg, "below"))
|
|
|
|
{
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_BELOW;
|
|
|
|
else
|
|
|
|
type |= vo_wm_BELOW;
|
|
|
|
} else if (!strcmp(arg, "netwm"))
|
|
|
|
{
|
|
|
|
if (neg)
|
|
|
|
type &= ~vo_wm_NETWM;
|
|
|
|
else
|
|
|
|
type |= vo_wm_NETWM;
|
|
|
|
} else if (!strcmp(arg, "none"))
|
2009-10-30 22:18:29 +00:00
|
|
|
type = 0; // clear; keep parsing
|
2003-02-07 19:38:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
return type;
|
2003-02-07 19:38:39 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
// update vo->dx, vo->dy, vo->dwidth and vo->dheight with current values of vo->x11->window
|
|
|
|
static void vo_x11_update_geometry(struct vo *vo, bool update_pos)
|
2008-11-17 18:50:23 +00:00
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2013-01-26 21:37:47 +00:00
|
|
|
unsigned w, h, dummy_uint;
|
2008-11-15 17:45:55 +00:00
|
|
|
int dummy_int;
|
|
|
|
Window dummy_win;
|
2008-11-17 18:50:23 +00:00
|
|
|
XGetGeometry(x11->display, x11->window, &dummy_win, &dummy_int, &dummy_int,
|
2013-01-26 21:37:47 +00:00
|
|
|
&w, &h, &dummy_int, &dummy_uint);
|
2008-11-17 18:50:23 +00:00
|
|
|
if (w <= INT_MAX && h <= INT_MAX) {
|
|
|
|
vo->dwidth = w;
|
|
|
|
vo->dheight = h;
|
|
|
|
}
|
2011-02-03 19:49:12 +00:00
|
|
|
if (update_pos)
|
|
|
|
XTranslateCoordinates(x11->display, x11->window, x11->rootwin, 0, 0,
|
|
|
|
&vo->dx, &vo->dy, &dummy_win);
|
2008-11-15 17:45:55 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 04:45:16 +00:00
|
|
|
void vo_x11_fullscreen(struct vo *vo)
|
2002-03-07 17:50:25 +00:00
|
|
|
{
|
2008-04-19 04:45:16 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
2008-04-20 06:34:27 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
int x, y, w, h;
|
2009-11-16 04:54:22 +00:00
|
|
|
x = x11->vo_old_x;
|
|
|
|
y = x11->vo_old_y;
|
|
|
|
w = x11->vo_old_width;
|
|
|
|
h = x11->vo_old_height;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2009-08-27 12:03:02 +00:00
|
|
|
if (WinID >= 0) {
|
|
|
|
vo_fs = !vo_fs;
|
|
|
|
return;
|
|
|
|
}
|
2009-09-04 16:49:35 +00:00
|
|
|
if (x11->fs_flip)
|
2004-06-14 04:53:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (vo_fs)
|
|
|
|
{
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_ewmh_fullscreen(x11, _NET_WM_STATE_REMOVE); // removes fullscreen state if wm supports EWMH
|
2004-07-11 22:16:52 +00:00
|
|
|
vo_fs = VO_FALSE;
|
2010-07-23 00:30:44 +00:00
|
|
|
if (x11->size_changed_during_fs && (x11->fs_type & vo_wm_FULLSCREEN))
|
|
|
|
vo_x11_nofs_sizepos(vo, vo->dx, vo->dy, x11->last_video_width,
|
|
|
|
x11->last_video_height);
|
|
|
|
x11->size_changed_during_fs = false;
|
2004-06-14 04:53:03 +00:00
|
|
|
} else
|
|
|
|
{
|
|
|
|
// win->fs
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_ewmh_fullscreen(x11, _NET_WM_STATE_ADD); // sends fullscreen state to be added if wm supports EWMH
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2004-07-11 22:16:52 +00:00
|
|
|
vo_fs = VO_TRUE;
|
2008-04-21 01:50:29 +00:00
|
|
|
if ( ! (x11->fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
|
2004-07-11 22:16:52 +00:00
|
|
|
{
|
2008-04-21 01:41:52 +00:00
|
|
|
x11->vo_old_x = vo->dx;
|
|
|
|
x11->vo_old_y = vo->dy;
|
|
|
|
x11->vo_old_width = vo->dwidth;
|
|
|
|
x11->vo_old_height = vo->dheight;
|
2007-07-28 22:21:29 +00:00
|
|
|
}
|
2013-01-26 21:37:47 +00:00
|
|
|
vo_x11_update_screeninfo(vo);
|
2006-04-16 13:38:28 +00:00
|
|
|
x = xinerama_x;
|
|
|
|
y = xinerama_y;
|
2008-04-20 23:18:28 +00:00
|
|
|
w = opts->vo_screenwidth;
|
|
|
|
h = opts->vo_screenheight;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
{
|
|
|
|
long dummy;
|
|
|
|
|
2008-04-21 01:19:43 +00:00
|
|
|
XGetWMNormalHints(x11->display, x11->window, &x11->vo_hint, &dummy);
|
|
|
|
if (!(x11->vo_hint.flags & PWinGravity))
|
2008-04-21 01:37:46 +00:00
|
|
|
x11->old_gravity = NorthWestGravity;
|
2004-06-14 04:53:03 +00:00
|
|
|
else
|
2008-04-21 01:37:46 +00:00
|
|
|
x11->old_gravity = x11->vo_hint.win_gravity;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2008-04-21 01:50:29 +00:00
|
|
|
if (x11->wm_type == 0 && !(vo_fsmode & 16))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-04-21 00:14:37 +00:00
|
|
|
XUnmapWindow(x11->display, x11->window); // required for MWM
|
2008-04-21 01:59:00 +00:00
|
|
|
XWithdrawWindow(x11->display, x11->window, x11->screen);
|
2008-04-21 01:50:29 +00:00
|
|
|
x11->fs_flip = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
2008-04-21 01:50:29 +00:00
|
|
|
if ( ! (x11->fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
|
2004-07-11 22:16:52 +00:00
|
|
|
{
|
2008-07-24 23:14:16 +00:00
|
|
|
vo_x11_decoration(vo, vo_border && !vo_fs);
|
2008-04-20 06:34:27 +00:00
|
|
|
vo_x11_sizehint(vo, x, y, w, h, 0);
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_setlayer(vo, x11->window, vo_fs);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
|
2008-04-21 00:14:37 +00:00
|
|
|
XMoveResizeWindow(x11->display, x11->window, x, y, w, h);
|
2004-07-11 22:16:52 +00:00
|
|
|
}
|
2007-01-18 09:03:42 +00:00
|
|
|
/* some WMs lose ontop after fullscreen */
|
2008-04-19 04:45:16 +00:00
|
|
|
if ((!(vo_fs)) & opts->vo_ontop)
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_setlayer(vo, x11->window, opts->vo_ontop);
|
2004-12-27 11:09:49 +00:00
|
|
|
|
2008-04-21 00:14:37 +00:00
|
|
|
XMapRaised(x11->display, x11->window);
|
2008-04-21 01:50:29 +00:00
|
|
|
if ( ! (x11->fs_type & vo_wm_FULLSCREEN) ) // some WMs change window pos on map
|
2008-04-21 00:14:37 +00:00
|
|
|
XMoveResizeWindow(x11->display, x11->window, x, y, w, h);
|
|
|
|
XRaiseWindow(x11->display, x11->window);
|
2008-04-20 06:34:27 +00:00
|
|
|
XFlush(x11->display);
|
2002-03-07 17:50:25 +00:00
|
|
|
}
|
|
|
|
|
2008-04-19 04:45:16 +00:00
|
|
|
void vo_x11_ontop(struct vo *vo)
|
2003-11-30 16:36:10 +00:00
|
|
|
{
|
2008-04-19 04:45:16 +00:00
|
|
|
struct MPOpts *opts = vo->opts;
|
|
|
|
opts->vo_ontop = !opts->vo_ontop;
|
2003-11-30 16:36:10 +00:00
|
|
|
|
2008-04-21 00:14:37 +00:00
|
|
|
vo_x11_setlayer(vo, vo->x11->window, opts->vo_ontop);
|
2003-11-30 16:36:10 +00:00
|
|
|
}
|
|
|
|
|
2008-07-24 23:14:16 +00:00
|
|
|
void vo_x11_border(struct vo *vo)
|
2008-07-22 18:46:07 +00:00
|
|
|
{
|
|
|
|
vo_border = !vo_border;
|
2008-07-24 23:14:16 +00:00
|
|
|
vo_x11_decoration(vo, vo_border && !vo_fs);
|
2008-07-22 18:46:07 +00:00
|
|
|
}
|
|
|
|
|
2003-03-26 17:02:28 +00:00
|
|
|
/*
|
|
|
|
* XScreensaver stuff
|
|
|
|
*/
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
void xscreensaver_heartbeat(struct vo_x11_state *x11)
|
2003-03-26 17:02:28 +00:00
|
|
|
{
|
2004-03-16 05:15:44 +00:00
|
|
|
unsigned int time = GetTimerMS();
|
2003-03-26 17:02:28 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (x11->display && x11->screensaver_off &&
|
|
|
|
(time - x11->screensaver_time_last) > 30000)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->screensaver_time_last = time;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
XResetScreenSaver(x11->display);
|
2003-03-26 17:02:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-20 06:34:27 +00:00
|
|
|
static int xss_suspend(Display *mDisplay, Bool suspend)
|
2007-12-22 11:09:43 +00:00
|
|
|
{
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifndef CONFIG_XSS
|
2007-12-22 11:09:43 +00:00
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
int event, error, major, minor;
|
|
|
|
if (XScreenSaverQueryExtension(mDisplay, &event, &error) != True ||
|
|
|
|
XScreenSaverQueryVersion(mDisplay, &major, &minor) != True)
|
|
|
|
return 0;
|
2008-06-15 11:11:39 +00:00
|
|
|
if (major < 1 || (major == 1 && minor < 1))
|
2007-12-22 11:09:43 +00:00
|
|
|
return 0;
|
|
|
|
XScreenSaverSuspend(mDisplay, suspend);
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2003-03-26 17:02:28 +00:00
|
|
|
/*
|
|
|
|
* End of XScreensaver stuff
|
|
|
|
*/
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void saver_on(struct vo_x11_state *x11)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
Display *mDisplay = x11->display;
|
|
|
|
if (!x11->screensaver_off)
|
2008-01-07 12:18:17 +00:00
|
|
|
return;
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->screensaver_off = 0;
|
2008-04-20 06:34:27 +00:00
|
|
|
if (xss_suspend(mDisplay, False))
|
2007-12-22 11:09:43 +00:00
|
|
|
return;
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XDPMS
|
2013-01-26 21:37:47 +00:00
|
|
|
if (x11->dpms_disabled) {
|
2007-12-20 12:51:24 +00:00
|
|
|
int nothing;
|
2013-01-26 21:37:47 +00:00
|
|
|
if (DPMSQueryExtension(mDisplay, ¬hing, ¬hing)) {
|
|
|
|
if (!DPMSEnable(mDisplay)) { // restoring power saving settings
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN, "DPMS not available?\n");
|
2013-01-26 21:37:47 +00:00
|
|
|
} else {
|
2001-05-09 20:15:37 +00:00
|
|
|
// DPMS does not seem to be enabled unless we call DPMSInfo
|
2004-06-14 04:53:03 +00:00
|
|
|
BOOL onoff;
|
|
|
|
CARD16 state;
|
|
|
|
|
|
|
|
DPMSForceLevel(mDisplay, DPMSModeOn);
|
|
|
|
DPMSInfo(mDisplay, &state, &onoff);
|
|
|
|
if (onoff)
|
|
|
|
{
|
2004-11-15 09:09:29 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V,
|
2004-06-14 04:53:03 +00:00
|
|
|
"Successfully enabled DPMS\n");
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_WARN, "Could not enable DPMS\n");
|
2001-05-09 20:15:37 +00:00
|
|
|
}
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->dpms_disabled = 0;
|
2001-04-10 00:00:04 +00:00
|
|
|
}
|
2001-07-19 18:47:22 +00:00
|
|
|
#endif
|
2001-04-10 00:00:04 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
static void saver_off(struct vo_x11_state *x11)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
Display *mDisplay = x11->display;
|
2001-07-19 18:47:22 +00:00
|
|
|
int nothing;
|
2001-04-10 00:00:04 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (x11->screensaver_off)
|
2008-01-07 12:18:17 +00:00
|
|
|
return;
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->screensaver_off = 1;
|
2008-04-20 06:34:27 +00:00
|
|
|
if (xss_suspend(mDisplay, True))
|
2007-12-22 11:09:43 +00:00
|
|
|
return;
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XDPMS
|
2001-04-10 00:00:04 +00:00
|
|
|
if (DPMSQueryExtension(mDisplay, ¬hing, ¬hing))
|
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
BOOL onoff;
|
|
|
|
CARD16 state;
|
|
|
|
|
|
|
|
DPMSInfo(mDisplay, &state, &onoff);
|
|
|
|
if (onoff)
|
|
|
|
{
|
|
|
|
Status stat;
|
|
|
|
|
2004-11-15 09:09:29 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "Disabling DPMS\n");
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->dpms_disabled = 1;
|
2004-06-14 04:53:03 +00:00
|
|
|
stat = DPMSDisable(mDisplay); // monitor powersave off
|
|
|
|
mp_msg(MSGT_VO, MSGL_V, "DPMSDisable stat: %d\n", stat);
|
|
|
|
}
|
2001-04-10 00:00:04 +00:00
|
|
|
}
|
2001-07-19 18:47:22 +00:00
|
|
|
#endif
|
2001-04-10 02:29:38 +00:00
|
|
|
}
|
2001-04-15 20:31:58 +00:00
|
|
|
|
2013-01-27 05:33:58 +00:00
|
|
|
static void vo_x11_selectinput_witherr(Display *display, Window w,
|
2013-01-26 21:37:47 +00:00
|
|
|
long event_mask)
|
2002-08-09 17:43:49 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
if (vo_nomouse_input)
|
2013-01-27 05:33:58 +00:00
|
|
|
event_mask &= ~(ButtonPressMask | ButtonReleaseMask);
|
|
|
|
|
|
|
|
// NOTE: this can raise BadAccess, which should be ignored by the X error
|
|
|
|
// handler; also see below
|
|
|
|
XSelectInput(display, w, event_mask);
|
|
|
|
|
|
|
|
// Test whether setting the event mask failed (with a BadAccess X error,
|
|
|
|
// although we don't know whether this really happened).
|
|
|
|
// This is needed for obscure situations like using --rootwin with a window
|
|
|
|
// manager active.
|
|
|
|
XWindowAttributes a;
|
|
|
|
if (XGetWindowAttributes(display, w, &a)) {
|
|
|
|
long bad = ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
|
|
|
|
if ((event_mask & bad) && (a.all_event_masks & bad) &&
|
|
|
|
((a.your_event_mask & bad) != (event_mask & bad)))
|
|
|
|
{
|
|
|
|
mp_msg(MSGT_VO, MSGL_ERR, "X11 error: error during XSelectInput "
|
|
|
|
"call, trying without mouse events\n");
|
|
|
|
XSelectInput(display, w, event_mask & ~bad);
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
2002-08-09 17:43:49 +00:00
|
|
|
}
|
2002-01-05 08:49:46 +00:00
|
|
|
|
2008-08-04 06:16:23 +00:00
|
|
|
#ifdef CONFIG_XF86VM
|
2013-01-27 06:21:10 +00:00
|
|
|
static void vo_x11_vm_switch(struct vo *vo)
|
2002-01-31 00:37:27 +00:00
|
|
|
{
|
2008-04-21 01:59:00 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
Display *mDisplay = x11->display;
|
2004-10-31 18:01:14 +00:00
|
|
|
int vm_event, vm_error;
|
|
|
|
int vm_ver, vm_rev;
|
2013-01-27 06:47:47 +00:00
|
|
|
int have_vm = 0;
|
2008-11-17 18:50:23 +00:00
|
|
|
int X = vo->dwidth, Y = vo->dheight;
|
2008-11-15 18:56:25 +00:00
|
|
|
int modeline_width, modeline_height;
|
2002-01-31 00:37:27 +00:00
|
|
|
|
2004-06-14 04:53:03 +00:00
|
|
|
if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error))
|
|
|
|
{
|
|
|
|
XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev);
|
2006-05-14 17:56:04 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_V, "XF86VidMode extension v%i.%i\n", vm_ver,
|
2004-06-14 04:53:03 +00:00
|
|
|
vm_rev);
|
|
|
|
have_vm = 1;
|
2008-11-15 18:11:10 +00:00
|
|
|
} else {
|
2004-06-14 04:53:03 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_WARN,
|
2006-05-14 17:56:04 +00:00
|
|
|
"XF86VidMode extension not available.\n");
|
2008-11-15 18:11:10 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
if (have_vm) {
|
2013-01-27 06:47:47 +00:00
|
|
|
if (!x11->vm_orig_w) {
|
|
|
|
int clock;
|
|
|
|
XF86VidModeModeLine modeline;
|
|
|
|
XF86VidModeGetModeLine(x11->display, x11->screen, &clock, &modeline);
|
|
|
|
x11->vm_orig_w = modeline.hdisplay;
|
|
|
|
x11->vm_orig_h = modeline.vdisplay;
|
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
int modecount = 0;
|
|
|
|
XF86VidModeModeInfo **vidmodes = NULL;
|
|
|
|
XF86VidModeGetAllModeLines(mDisplay, x11->screen, &modecount, &vidmodes);
|
2013-01-27 06:47:47 +00:00
|
|
|
if (modecount == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
int j = 0;
|
2008-11-15 18:56:25 +00:00
|
|
|
modeline_width = vidmodes[0]->hdisplay;
|
|
|
|
modeline_height = vidmodes[0]->vdisplay;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-27 06:47:47 +00:00
|
|
|
for (int i = 1; i < modecount; i++) {
|
2004-06-14 04:53:03 +00:00
|
|
|
if ((vidmodes[i]->hdisplay >= X)
|
|
|
|
&& (vidmodes[i]->vdisplay >= Y))
|
2013-01-26 21:37:47 +00:00
|
|
|
{
|
2008-11-15 18:56:25 +00:00
|
|
|
if ((vidmodes[i]->hdisplay <= modeline_width)
|
|
|
|
&& (vidmodes[i]->vdisplay <= modeline_height))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2008-11-15 18:56:25 +00:00
|
|
|
modeline_width = vidmodes[i]->hdisplay;
|
|
|
|
modeline_height = vidmodes[i]->vdisplay;
|
2004-06-14 04:53:03 +00:00
|
|
|
j = i;
|
|
|
|
}
|
2013-01-26 21:37:47 +00:00
|
|
|
}
|
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_VO, MSGL_INFO, "XF86VM: Selected video mode %dx%d for image size %dx%d.\n",
|
2008-11-15 18:56:25 +00:00
|
|
|
modeline_width, modeline_height, X, Y);
|
2008-04-21 01:59:00 +00:00
|
|
|
XF86VidModeLockModeSwitch(mDisplay, x11->screen, 0);
|
|
|
|
XF86VidModeSwitchToMode(mDisplay, x11->screen, vidmodes[j]);
|
2008-11-15 18:28:35 +00:00
|
|
|
|
|
|
|
// FIXME: all this is more of a hack than proper solution
|
2013-01-27 06:47:47 +00:00
|
|
|
// center the video if the screen has different size
|
|
|
|
X = (x11->vm_orig_w - modeline_width) / 2;
|
|
|
|
Y = (x11->vm_orig_h - modeline_height) / 2;
|
2008-04-21 01:59:00 +00:00
|
|
|
XF86VidModeSetViewPort(mDisplay, x11->screen, X, Y);
|
2008-11-17 18:50:23 +00:00
|
|
|
vo->dx = X;
|
|
|
|
vo->dy = Y;
|
|
|
|
vo->dwidth = modeline_width;
|
|
|
|
vo->dheight = modeline_height;
|
|
|
|
aspect_save_screenres(vo, modeline_width, modeline_height);
|
2013-01-26 21:37:47 +00:00
|
|
|
|
|
|
|
x11->vm_set = 1;
|
|
|
|
free(vidmodes);
|
2002-01-31 00:37:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-27 06:21:10 +00:00
|
|
|
static void vo_x11_vm_close(struct vo *vo)
|
2002-01-31 00:37:27 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
Display *dpy = x11->display;
|
|
|
|
if (x11->vm_set) {
|
|
|
|
int modecount = 0;
|
|
|
|
XF86VidModeModeInfo **vidmodes = NULL;
|
2013-01-27 06:47:47 +00:00
|
|
|
XF86VidModeModeInfo *mode = NULL;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
XF86VidModeGetAllModeLines(dpy, x11->screen, &modecount, &vidmodes);
|
2013-01-27 06:47:47 +00:00
|
|
|
for (int i = 0; i < modecount; i++) {
|
|
|
|
if ((vidmodes[i]->hdisplay == x11->vm_orig_w)
|
|
|
|
&& (vidmodes[i]->vdisplay == x11->vm_orig_h))
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-27 06:47:47 +00:00
|
|
|
mp_msg(MSGT_VO, MSGL_INFO, "Returning to original mode %dx%d\n",
|
|
|
|
x11->vm_orig_w, x11->vm_orig_h);
|
|
|
|
mode = vidmodes[i];
|
2004-06-14 04:53:03 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-01-27 06:47:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mode)
|
|
|
|
XF86VidModeSwitchToMode(dpy, x11->screen, mode);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
free(vidmodes);
|
|
|
|
}
|
2002-01-31 00:37:27 +00:00
|
|
|
}
|
2009-11-15 02:39:22 +00:00
|
|
|
|
2013-01-27 06:21:10 +00:00
|
|
|
double vo_x11_vm_get_fps(struct vo *vo)
|
2009-11-15 02:39:22 +00:00
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
int clock;
|
|
|
|
XF86VidModeModeLine modeline;
|
|
|
|
if (!XF86VidModeGetModeLine(x11->display, x11->screen, &clock, &modeline))
|
|
|
|
return 0;
|
|
|
|
if (modeline.privsize)
|
2009-11-15 13:21:40 +00:00
|
|
|
XFree(modeline.private);
|
2009-11-15 02:39:22 +00:00
|
|
|
return 1e3 * clock / modeline.htotal / modeline.vtotal;
|
|
|
|
}
|
2013-01-27 06:21:10 +00:00
|
|
|
|
|
|
|
#else /* CONFIG_XF86VM */
|
|
|
|
|
|
|
|
static void vo_x11_vm_switch(struct vo *vo)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vo_x11_vm_close(struct vo *vo)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
double vo_vm_get_fps(struct vo *vo)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-01-31 00:37:27 +00:00
|
|
|
#endif
|
|
|
|
|
2002-09-03 18:10:42 +00:00
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
static void vo_x11_create_colormap(struct vo_x11_state *x11,
|
|
|
|
XVisualInfo *vinfo)
|
2002-10-29 20:27:47 +00:00
|
|
|
{
|
2004-06-14 04:53:03 +00:00
|
|
|
unsigned k, r, g, b, ru, gu, bu, m, rv, gv, bv, rvu, gvu, bvu;
|
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
if (x11->colormap != None)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vinfo->class != DirectColor) {
|
|
|
|
x11->colormap = XCreateColormap(x11->display, x11->rootwin,
|
|
|
|
vinfo->visual, AllocNone);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// DirectColor is requested by vo_x11 by default, for the equalizer
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->cm_size = vinfo->colormap_size;
|
|
|
|
x11->red_mask = vinfo->red_mask;
|
|
|
|
x11->green_mask = vinfo->green_mask;
|
|
|
|
x11->blue_mask = vinfo->blue_mask;
|
|
|
|
ru = (x11->red_mask & (x11->red_mask - 1)) ^ x11->red_mask;
|
|
|
|
gu = (x11->green_mask & (x11->green_mask - 1)) ^ x11->green_mask;
|
|
|
|
bu = (x11->blue_mask & (x11->blue_mask - 1)) ^ x11->blue_mask;
|
|
|
|
rvu = 65536ull * ru / (x11->red_mask + ru);
|
|
|
|
gvu = 65536ull * gu / (x11->green_mask + gu);
|
|
|
|
bvu = 65536ull * bu / (x11->blue_mask + bu);
|
2004-06-14 04:53:03 +00:00
|
|
|
r = g = b = 0;
|
|
|
|
rv = gv = bv = 0;
|
|
|
|
m = DoRed | DoGreen | DoBlue;
|
2013-01-26 21:37:47 +00:00
|
|
|
for (k = 0; k < x11->cm_size; k++)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
|
|
|
int t;
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->cols[k].pixel = r | g | b;
|
|
|
|
x11->cols[k].red = rv;
|
|
|
|
x11->cols[k].green = gv;
|
|
|
|
x11->cols[k].blue = bv;
|
|
|
|
x11->cols[k].flags = m;
|
|
|
|
t = (r + ru) & x11->red_mask;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (t < r)
|
|
|
|
m &= ~DoRed;
|
|
|
|
r = t;
|
2013-01-26 21:37:47 +00:00
|
|
|
t = (g + gu) & x11->green_mask;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (t < g)
|
|
|
|
m &= ~DoGreen;
|
|
|
|
g = t;
|
2013-01-26 21:37:47 +00:00
|
|
|
t = (b + bu) & x11->blue_mask;
|
2004-06-14 04:53:03 +00:00
|
|
|
if (t < b)
|
|
|
|
m &= ~DoBlue;
|
|
|
|
b = t;
|
|
|
|
rv += rvu;
|
|
|
|
gv += gvu;
|
|
|
|
bv += bvu;
|
|
|
|
}
|
2013-01-27 11:01:08 +00:00
|
|
|
x11->colormap = XCreateColormap(x11->display, x11->rootwin, vinfo->visual,
|
|
|
|
AllocAll);
|
|
|
|
XStoreColors(x11->display, x11->colormap, x11->cols, x11->cm_size);
|
2002-10-29 20:27:47 +00:00
|
|
|
}
|
|
|
|
|
2008-01-12 16:30:41 +00:00
|
|
|
static int transform_color(float val,
|
|
|
|
float brightness, float contrast, float gamma) {
|
|
|
|
float s = pow(val, gamma);
|
|
|
|
s = (s - 0.5) * contrast + 0.5;
|
|
|
|
s += brightness;
|
|
|
|
if (s < 0)
|
|
|
|
s = 0;
|
|
|
|
if (s > 1)
|
|
|
|
s = 1;
|
|
|
|
return (unsigned short) (s * 65535);
|
|
|
|
}
|
2002-10-29 20:27:47 +00:00
|
|
|
|
2011-03-07 20:50:45 +00:00
|
|
|
uint32_t vo_x11_set_equalizer(struct vo *vo, const char *name, int value)
|
2002-10-29 20:27:47 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2004-06-14 04:53:03 +00:00
|
|
|
float gamma, brightness, contrast;
|
|
|
|
float rf, gf, bf;
|
|
|
|
int k;
|
2013-01-26 21:37:47 +00:00
|
|
|
int red_mask = x11->red_mask;
|
|
|
|
int green_mask = x11->green_mask;
|
|
|
|
int blue_mask = x11->blue_mask;
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* IMPLEMENTME: consider using XF86VidModeSetGammaRamp in the case
|
|
|
|
* of TrueColor-ed window but be careful:
|
2007-01-18 09:03:42 +00:00
|
|
|
* Unlike the colormaps, which are private for the X client
|
2004-06-14 04:53:03 +00:00
|
|
|
* who created them and thus automatically destroyed on client
|
|
|
|
* disconnect, this gamma ramp is a system-wide (X-server-wide)
|
2007-01-18 09:03:42 +00:00
|
|
|
* setting and _must_ be restored before the process exits.
|
|
|
|
* Unforunately when the process crashes (or gets killed
|
2004-06-14 04:53:03 +00:00
|
|
|
* for some reason) it is impossible to restore the setting,
|
|
|
|
* and such behaviour could be rather annoying for the users.
|
|
|
|
*/
|
2013-01-27 11:01:08 +00:00
|
|
|
if (x11->colormap == None)
|
2004-06-14 04:53:03 +00:00
|
|
|
return VO_NOTAVAIL;
|
|
|
|
|
|
|
|
if (!strcasecmp(name, "brightness"))
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->vo_brightness = value;
|
2004-06-14 04:53:03 +00:00
|
|
|
else if (!strcasecmp(name, "contrast"))
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->vo_contrast = value;
|
2004-06-14 04:53:03 +00:00
|
|
|
else if (!strcasecmp(name, "gamma"))
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->vo_gamma = value;
|
2004-06-14 04:53:03 +00:00
|
|
|
else
|
|
|
|
return VO_NOTIMPL;
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
brightness = 0.01 * x11->vo_brightness;
|
|
|
|
contrast = tan(0.0095 * (x11->vo_contrast + 100) * M_PI / 4);
|
|
|
|
gamma = pow(2, -0.02 * x11->vo_gamma);
|
2004-06-14 04:53:03 +00:00
|
|
|
|
|
|
|
rf = (float) ((red_mask & (red_mask - 1)) ^ red_mask) / red_mask;
|
|
|
|
gf = (float) ((green_mask & (green_mask - 1)) ^ green_mask) /
|
|
|
|
green_mask;
|
|
|
|
bf = (float) ((blue_mask & (blue_mask - 1)) ^ blue_mask) / blue_mask;
|
|
|
|
|
|
|
|
/* now recalculate the colormap using the newly set value */
|
2013-01-26 21:37:47 +00:00
|
|
|
for (k = 0; k < x11->cm_size; k++)
|
2004-06-14 04:53:03 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
x11->cols[k].red = transform_color(rf * k, brightness, contrast, gamma);
|
|
|
|
x11->cols[k].green = transform_color(gf * k, brightness, contrast, gamma);
|
|
|
|
x11->cols[k].blue = transform_color(bf * k, brightness, contrast, gamma);
|
2004-06-14 04:53:03 +00:00
|
|
|
}
|
|
|
|
|
2013-01-27 11:01:08 +00:00
|
|
|
XStoreColors(vo->x11->display, x11->colormap, x11->cols, x11->cm_size);
|
2008-04-20 06:34:27 +00:00
|
|
|
XFlush(vo->x11->display);
|
2004-06-14 04:53:03 +00:00
|
|
|
return VO_TRUE;
|
2002-10-29 20:27:47 +00:00
|
|
|
}
|
|
|
|
|
2013-01-26 21:37:47 +00:00
|
|
|
uint32_t vo_x11_get_equalizer(struct vo *vo, const char *name, int *value)
|
2002-10-29 20:27:47 +00:00
|
|
|
{
|
2013-01-26 21:37:47 +00:00
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
2013-01-27 11:01:08 +00:00
|
|
|
if (x11->colormap == None)
|
2004-06-14 04:53:03 +00:00
|
|
|
return VO_NOTAVAIL;
|
|
|
|
if (!strcasecmp(name, "brightness"))
|
2013-01-26 21:37:47 +00:00
|
|
|
*value = x11->vo_brightness;
|
2004-06-14 04:53:03 +00:00
|
|
|
else if (!strcasecmp(name, "contrast"))
|
2013-01-26 21:37:47 +00:00
|
|
|
*value = x11->vo_contrast;
|
2004-06-14 04:53:03 +00:00
|
|
|
else if (!strcasecmp(name, "gamma"))
|
2013-01-26 21:37:47 +00:00
|
|
|
*value = x11->vo_gamma;
|
2004-06-14 04:53:03 +00:00
|
|
|
else
|
|
|
|
return VO_NOTIMPL;
|
|
|
|
return VO_TRUE;
|
2002-10-29 20:27:47 +00:00
|
|
|
}
|
2004-06-14 04:53:03 +00:00
|
|
|
|
2012-07-27 00:40:38 +00:00
|
|
|
bool vo_x11_screen_is_composited(struct vo *vo)
|
|
|
|
{
|
|
|
|
struct vo_x11_state *x11 = vo->x11;
|
|
|
|
return XGetSelectionOwner(x11->display, x11->XA_NET_WM_CM) != None;
|
|
|
|
}
|