Mercurial > mplayer.hg
annotate libvo/x11_common.c @ 34021:fbb87f092560
Get rid of usage of deprecated palctrl which no longer works anyway.
Set up side data instead.
Note that for lavf demuxer we will use the merged side data anyway,
this is only for our own, e.g. AVI demuxer.
Fixes bug #1976.
author | reimar |
---|---|
date | Sat, 17 Sep 2011 16:48:40 +0000 |
parents | 6b9553934e5d |
children | e7f393cb9d0f |
rev | line source |
---|---|
28446
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
1 /* |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
2 * This file is part of MPlayer. |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
3 * |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
4 * MPlayer is free software; you can redistribute it and/or modify |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
6 * the Free Software Foundation; either version 2 of the License, or |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
7 * (at your option) any later version. |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
8 * |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
9 * MPlayer is distributed in the hope that it will be useful, |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
12 * GNU General Public License for more details. |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
13 * |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
14 * You should have received a copy of the GNU General Public License along |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
15 * with MPlayer; if not, write to the Free Software Foundation, Inc., |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
7681eab10aea
Add standard license headers, unify header formatting.
diego
parents:
28250
diff
changeset
|
17 */ |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
18 |
32 | 19 #include <stdio.h> |
20 #include <stdlib.h> | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
21 #include <math.h> |
6401 | 22 #include <inttypes.h> |
27893 | 23 #include <limits.h> |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
24 |
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
25 #include "config.h" |
5998 | 26 #include "mp_msg.h" |
22823
98eaf29b5dee
Code cleanup: don't include a .c file in mplayer.c and fix a few
rathann
parents:
21964
diff
changeset
|
27 #include "mp_fifo.h" |
28250 | 28 #include "libavutil/common.h" |
6401 | 29 #include "x11_common.h" |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
30 |
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
31 #ifdef X11_FULLSCREEN |
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
32 |
440
d19a3da6ac13
Pontscho's mixer, select, and hell-a-lot-of-stuff patch ;)
gabucino
parents:
416
diff
changeset
|
33 #include <string.h> |
32 | 34 #include <unistd.h> |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
35 #include <assert.h> |
32 | 36 |
37 #include "video_out.h" | |
10889 | 38 #include "aspect.h" |
12032
8cc4d4344c0f
Don't mess with the window position in xinerama when -geometry changes it.
diego
parents:
12031
diff
changeset
|
39 #include "geometry.h" |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
40 #include "help_mp.h" |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
12972
diff
changeset
|
41 #include "osdep/timer.h" |
32 | 42 |
324 | 43 #include <X11/Xmd.h> |
32 | 44 #include <X11/Xlib.h> |
45 #include <X11/Xutil.h> | |
46 #include <X11/Xatom.h> | |
47 | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
48 #ifdef CONFIG_XSS |
25482 | 49 #include <X11/extensions/scrnsaver.h> |
50 #endif | |
51 | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
52 #ifdef CONFIG_XDPMS |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
53 #include <X11/extensions/dpms.h> |
1345
be674b95b485
x11_common does not compile, when the XDPMS extension is not available on the
jkeil
parents:
1266
diff
changeset
|
54 #endif |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
55 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
56 #ifdef CONFIG_XINERAMA |
2149
6358db6ad3d0
Xinerama screen size fix by Lev Babiev <harley@hosers.org>
arpi
parents:
1746
diff
changeset
|
57 #include <X11/extensions/Xinerama.h> |
6358db6ad3d0
Xinerama screen size fix by Lev Babiev <harley@hosers.org>
arpi
parents:
1746
diff
changeset
|
58 #endif |
1732 | 59 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
60 #ifdef CONFIG_XF86VM |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
61 #include <X11/extensions/xf86vmode.h> |
14636
408bcfa575bf
Separate XF86 video mode extension check from XF86 keysym check as
diego
parents:
14244
diff
changeset
|
62 #endif |
408bcfa575bf
Separate XF86 video mode extension check from XF86 keysym check as
diego
parents:
14244
diff
changeset
|
63 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
64 #ifdef CONFIG_XF86XK |
9822
1e761763566c
Support for "internet" or "multimedia" keyboards in X11.
albeu
parents:
9695
diff
changeset
|
65 #include <X11/XF86keysym.h> |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
66 #endif |
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
67 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
68 #ifdef CONFIG_XV |
10359 | 69 #include <X11/extensions/Xv.h> |
70 #include <X11/extensions/Xvlib.h> | |
14742 | 71 |
72 #include "subopt-helper.h" | |
10359 | 73 #endif |
74 | |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
12972
diff
changeset
|
75 #include "input/input.h" |
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
12972
diff
changeset
|
76 #include "input/mouse.h" |
4658 | 77 |
27343 | 78 #ifdef CONFIG_GUI |
23077 | 79 #include "gui/interface.h" |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
12972
diff
changeset
|
80 #include "mplayer.h" |
4798 | 81 #endif |
82 | |
8660
39476cbd1673
I have looked at the fullscreen code and realized that there are
arpi
parents:
8653
diff
changeset
|
83 #define WIN_LAYER_ONBOTTOM 2 |
39476cbd1673
I have looked at the fullscreen code and realized that there are
arpi
parents:
8653
diff
changeset
|
84 #define WIN_LAYER_NORMAL 4 |
39476cbd1673
I have looked at the fullscreen code and realized that there are
arpi
parents:
8653
diff
changeset
|
85 #define WIN_LAYER_ONTOP 6 |
8669
fd398a0b4b3b
This time the patch is fixing much more that breaking :-)
arpi
parents:
8663
diff
changeset
|
86 #define WIN_LAYER_ABOVE_DOCK 10 |
12582 | 87 |
88 int fs_layer = WIN_LAYER_ABOVE_DOCK; | |
89 static int orig_layer = 0; | |
12111
8e31aacc3e81
- win_gravity memorizing and restoring while switching fullscreen mode (by Adam Tla/lka)
rathann
parents:
12096
diff
changeset
|
90 static int old_gravity = NorthWestGravity; |
8866 | 91 |
33988
6b9553934e5d
Change stop_xscreensaver default to 1 to be more user-friendly.
reimar
parents:
33986
diff
changeset
|
92 int stop_xscreensaver = 1; |
6202 | 93 |
12582 | 94 static int dpms_disabled = 0; |
324 | 95 |
33461
175e9084ee62
Remove needless explicit initialization of Display variables.
ib
parents:
33437
diff
changeset
|
96 char *mDisplayName; |
175e9084ee62
Remove needless explicit initialization of Display variables.
ib
parents:
33437
diff
changeset
|
97 Display *mDisplay; |
12582 | 98 Window mRootWin; |
922
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
99 int mScreen; |
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
100 int mLocalDisplay; |
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
101 |
3830 | 102 /* output window id */ |
5955
caac20b1ca79
fix xmga fs, resize to movie size and mouse auto hide + dga
pontscho
parents:
5919
diff
changeset
|
103 int vo_mouse_autohide = 0; |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
104 int vo_wm_type = 0; |
12796
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
105 int vo_fs_type = 0; // needs to be accessible for GUI X11 code |
30465
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
106 static int window_state; |
12125
f4fc74a88e65
full screen flipping synchronization corrections (by Adam Tla/lka)
rathann
parents:
12123
diff
changeset
|
107 static int vo_fs_flip = 0; |
12582 | 108 char **vo_fstype_list; |
384 | 109 |
21938 | 110 /* 1 means that the WM is metacity (broken as hell) */ |
8835
664b0612f950
Fixed metacity + xv behavior (something broke it lately).
filon
parents:
8783
diff
changeset
|
111 int metacity_hack = 0; |
664b0612f950
Fixed metacity + xv behavior (something broke it lately).
filon
parents:
8783
diff
changeset
|
112 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
113 static Atom XA_NET_SUPPORTED; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
114 static Atom XA_NET_WM_STATE; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
115 static Atom XA_NET_WM_STATE_FULLSCREEN; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
116 static Atom XA_NET_WM_STATE_ABOVE; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
117 static Atom XA_NET_WM_STATE_STAYS_ON_TOP; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
118 static Atom XA_NET_WM_STATE_BELOW; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
119 static Atom XA_NET_WM_PID; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
120 static Atom XA_WIN_PROTOCOLS; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
121 static Atom XA_WIN_LAYER; |
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
122 static Atom XA_WIN_HINTS; |
18149
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
123 static Atom XAWM_PROTOCOLS; |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
124 static Atom XAWM_DELETE_WINDOW; |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
125 |
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
126 #define XA_INIT(x) XA##x = XInternAtom(mDisplay, #x, False) |
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
127 |
7435 | 128 static int vo_old_x = 0; |
129 static int vo_old_y = 0; | |
130 static int vo_old_width = 0; | |
131 static int vo_old_height = 0; | |
132 | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
133 #ifdef CONFIG_XF86VM |
12582 | 134 XF86VidModeModeInfo **vidmodes = NULL; |
4977
7b65a4f0b74e
vm pecs applied from daniel carter <hedonist@win.co.nz>
pontscho
parents:
4974
diff
changeset
|
135 XF86VidModeModeLine modeline; |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
136 #endif |
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
137 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
138 static int vo_x11_get_fs_type(int supported); |
10212
d358fa9a1068
warning fixes by Dominik Mierzejewski <dominik@rangers.eu.org>
alex
parents:
10193
diff
changeset
|
139 |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
140 |
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
141 /* |
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
142 * Sends the EWMH fullscreen state event. |
21938 | 143 * |
33937 | 144 * win: id of the window to which the event shall be sent |
21938 | 145 * action: could be one of _NET_WM_STATE_REMOVE -- remove state |
146 * _NET_WM_STATE_ADD -- add state | |
147 * _NET_WM_STATE_TOGGLE -- toggle | |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
148 */ |
33937 | 149 void vo_x11_ewmh_fullscreen(Window win, int action) |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
150 { |
12582 | 151 assert(action == _NET_WM_STATE_REMOVE || |
152 action == _NET_WM_STATE_ADD || action == _NET_WM_STATE_TOGGLE); | |
153 | |
154 if (vo_fs_type & vo_wm_FULLSCREEN) | |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
155 { |
12582 | 156 XEvent xev; |
157 | |
21938 | 158 /* init X event structure for _NET_WM_FULLSCREEN client message */ |
12582 | 159 xev.xclient.type = ClientMessage; |
160 xev.xclient.serial = 0; | |
161 xev.xclient.send_event = True; | |
27616
213d9bc30b35
Use already "prefetched" atoms instead of calling XInternAtom each time.
reimar
parents:
27377
diff
changeset
|
162 xev.xclient.message_type = XA_NET_WM_STATE; |
33937 | 163 xev.xclient.window = win; |
12582 | 164 xev.xclient.format = 32; |
165 xev.xclient.data.l[0] = action; | |
27616
213d9bc30b35
Use already "prefetched" atoms instead of calling XInternAtom each time.
reimar
parents:
27377
diff
changeset
|
166 xev.xclient.data.l[1] = XA_NET_WM_STATE_FULLSCREEN; |
12582 | 167 xev.xclient.data.l[2] = 0; |
168 xev.xclient.data.l[3] = 0; | |
169 xev.xclient.data.l[4] = 0; | |
170 | |
171 /* finally send that damn thing */ | |
172 if (!XSendEvent(mDisplay, DefaultRootWindow(mDisplay), False, | |
173 SubstructureRedirectMask | SubstructureNotifyMask, | |
174 &xev)) | |
175 { | |
176 mp_msg(MSGT_VO, MSGL_ERR, MSGTR_EwmhFullscreenStateFailed); | |
177 } | |
12520
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
178 } |
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
179 } |
94e66acdb706
Metacity fullscreen issues, patch by Alexander Strasser <eclipse7@gmx.net>,
diego
parents:
12371
diff
changeset
|
180 |
33966 | 181 static void vo_hidecursor(Display * disp, Window win) |
384 | 182 { |
12582 | 183 Cursor no_ptr; |
184 Pixmap bm_no; | |
185 XColor black, dummy; | |
186 Colormap colormap; | |
13828
b4ad5f0b550d
Fix erroneus extern declarations, fix wrong signedness of some vars
atmos4
parents:
13787
diff
changeset
|
187 static char bm_no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
3954 | 188 |
12582 | 189 if (WinID == 0) |
21938 | 190 return; // do not hide if playing on the root window |
12582 | 191 |
192 colormap = DefaultColormap(disp, DefaultScreen(disp)); | |
14743
465c8617cbe5
We should not crash, only because we couldn't hide the cursor.
al
parents:
14742
diff
changeset
|
193 if ( !XAllocNamedColor(disp, colormap, "black", &black, &dummy) ) |
465c8617cbe5
We should not crash, only because we couldn't hide the cursor.
al
parents:
14742
diff
changeset
|
194 { |
31536 | 195 return; // color alloc failed, give up |
14743
465c8617cbe5
We should not crash, only because we couldn't hide the cursor.
al
parents:
14742
diff
changeset
|
196 } |
12582 | 197 bm_no = XCreateBitmapFromData(disp, win, bm_no_data, 8, 8); |
198 no_ptr = XCreatePixmapCursor(disp, bm_no, bm_no, &black, &black, 0, 0); | |
199 XDefineCursor(disp, win, no_ptr); | |
200 XFreeCursor(disp, no_ptr); | |
201 if (bm_no != None) | |
202 XFreePixmap(disp, bm_no); | |
13953 | 203 XFreeColors(disp,colormap,&black.pixel,1,0); |
384 | 204 } |
205 | |
33966 | 206 static void vo_showcursor(Display * disp, Window win) |
12582 | 207 { |
208 if (WinID == 0) | |
209 return; | |
210 XDefineCursor(disp, win, 0); | |
5955
caac20b1ca79
fix xmga fs, resize to movie size and mouse auto hide + dga
pontscho
parents:
5919
diff
changeset
|
211 } |
384 | 212 |
12582 | 213 static int x11_errorhandler(Display * display, XErrorEvent * event) |
4742 | 214 { |
215 #define MSGLEN 60 | |
216 char msg[MSGLEN]; | |
12582 | 217 |
218 XGetErrorText(display, event->error_code, (char *) &msg, MSGLEN); | |
219 | |
220 mp_msg(MSGT_VO, MSGL_ERR, "X11 error: %s\n", msg); | |
221 | |
222 mp_msg(MSGT_VO, MSGL_V, | |
17366 | 223 "Type: %x, display: %p, resourceid: %lx, serial: %lx\n", |
12582 | 224 event->type, event->display, event->resourceid, event->serial); |
225 mp_msg(MSGT_VO, MSGL_V, | |
226 "Error code: %x, request code: %x, minor code: %x\n", | |
227 event->error_code, event->request_code, event->minor_code); | |
228 | |
21808
eaf6ed9cb5ab
Do not abort on X11 errors, most are not at all fatal.
reimar
parents:
21623
diff
changeset
|
229 // abort(); |
23615 | 230 return 0; |
4742 | 231 #undef MSGLEN |
232 } | |
1732 | 233 |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
234 void fstype_help(void) |
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
235 { |
12582 | 236 mp_msg(MSGT_VO, MSGL_INFO, MSGTR_AvailableFsType); |
18237
4231482179b6
Get ride of the several if(identify) messy lines and rearangment of some of the output, both patches by Kiriuja mplayer-patches AT en-directo_net, his changes are barely unrelated, nevertheless Im commiting them thogeter just for the sake of my mental healt, I had both patches already applied on my local three
reynaldo
parents:
18160
diff
changeset
|
237 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_FULL_SCREEN_TYPES\n"); |
12582 | 238 |
239 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "none", | |
240 "don't set fullscreen window layer"); | |
241 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "layer", | |
242 "use _WIN_LAYER hint with default layer"); | |
243 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "layer=<0..15>", | |
244 "use _WIN_LAYER hint with a given layer number"); | |
245 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "netwm", | |
246 "force NETWM style"); | |
247 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "above", | |
248 "use _NETWM_STATE_ABOVE hint if available"); | |
249 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "below", | |
250 "use _NETWM_STATE_BELOW hint if available"); | |
251 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "fullscreen", | |
31834
64ba1daa147a
various spelling fixes, found by the Debian QA tool 'lintian'
siretart
parents:
31606
diff
changeset
|
252 "use _NETWM_STATE_FULLSCREEN hint if available"); |
12582 | 253 mp_msg(MSGT_VO, MSGL_INFO, " %-15s %s\n", "stays_on_top", |
254 "use _NETWM_STATE_STAYS_ON_TOP hint if available"); | |
255 mp_msg(MSGT_VO, MSGL_INFO, | |
256 "You can also negate the settings with simply putting '-' in the beginning"); | |
17727
096cb1dfb591
Make -xy help output consistent, output an empty line before and after.
diego
parents:
17566
diff
changeset
|
257 mp_msg(MSGT_VO, MSGL_INFO, "\n"); |
10695
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
258 } |
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
259 |
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
260 static void fstype_dump(int fstype) |
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
261 { |
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
262 if (fstype) |
879ce4016b34
Commit alex's fstype patch x11_common.c3.diff with additional manpage extension.
attila
parents:
10587
diff
changeset
|
263 { |
12582 | 264 mp_msg(MSGT_VO, MSGL_V, "[x11] Current fstype setting honours"); |
265 if (fstype & vo_wm_LAYER) | |
266 mp_msg(MSGT_VO, MSGL_V, " LAYER"); | |
267 if (fstype & vo_wm_FULLSCREEN) | |
268 mp_msg(MSGT_VO, MSGL_V, " FULLSCREEN"); | |
269 if (fstype & vo_wm_STAYS_ON_TOP) | |
270 mp_msg(MSGT_VO, MSGL_V, " STAYS_ON_TOP"); | |
271 if (fstype & vo_wm_ABOVE) | |
272 mp_msg(MSGT_VO, MSGL_V, " ABOVE"); | |
273 if (fstype & vo_wm_BELOW) | |
274 mp_msg(MSGT_VO, MSGL_V, " BELOW"); | |
275 mp_msg(MSGT_VO, MSGL_V, " X atoms\n"); | |
276 } else | |
277 mp_msg(MSGT_VO, MSGL_V, | |
278 "[x11] Current fstype setting doesn't honour any X atoms\n"); | |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
279 } |
12582 | 280 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
281 static int net_wm_support_state_test(Atom atom) |
8653 | 282 { |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
283 #define NET_WM_STATE_TEST(x) { if (atom == XA_NET_WM_STATE_##x) { mp_msg( MSGT_VO,MSGL_V, "[x11] Detected wm supports " #x " state.\n" ); return vo_wm_##x; } } |
12582 | 284 |
285 NET_WM_STATE_TEST(FULLSCREEN); | |
286 NET_WM_STATE_TEST(ABOVE); | |
287 NET_WM_STATE_TEST(STAYS_ON_TOP); | |
288 NET_WM_STATE_TEST(BELOW); | |
289 return 0; | |
8653 | 290 } |
291 | |
12582 | 292 static int x11_get_property(Atom type, Atom ** args, unsigned long *nitems) |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
293 { |
12582 | 294 int format; |
295 unsigned long bytesafter; | |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
296 |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
297 return Success == |
12582 | 298 XGetWindowProperty(mDisplay, mRootWin, type, 0, 16384, False, |
299 AnyPropertyType, &type, &format, nitems, | |
300 &bytesafter, (unsigned char **) args) | |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
301 && *nitems > 0; |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
302 } |
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
303 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
304 static int vo_wm_detect(void) |
6009 | 305 { |
12582 | 306 int i; |
307 int wm = 0; | |
308 unsigned long nitems; | |
309 Atom *args = NULL; | |
310 | |
311 if (WinID >= 0) | |
312 return 0; | |
313 | |
8669
fd398a0b4b3b
This time the patch is fixing much more that breaking :-)
arpi
parents:
8663
diff
changeset
|
314 // -- supports layers |
12582 | 315 if (x11_get_property(XA_WIN_PROTOCOLS, &args, &nitems)) |
316 { | |
317 mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports layers.\n"); | |
318 for (i = 0; i < nitems; i++) | |
319 { | |
320 if (args[i] == XA_WIN_LAYER) | |
321 { | |
322 wm |= vo_wm_LAYER; | |
323 metacity_hack |= 1; | |
324 } else | |
21938 | 325 /* metacity is the only window manager I know which reports |
326 * supporting only the _WIN_LAYER hint in _WIN_PROTOCOLS. | |
327 * (what's more support for it is broken) */ | |
12582 | 328 metacity_hack |= 2; |
329 } | |
330 XFree(args); | |
331 if (wm && (metacity_hack == 1)) | |
332 { | |
21938 | 333 // metacity claims to support layers, but it is not the truth :-) |
12582 | 334 wm ^= vo_wm_LAYER; |
335 mp_msg(MSGT_VO, MSGL_V, | |
336 "[x11] Using workaround for Metacity bugs.\n"); | |
337 } | |
338 } | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
339 // --- netwm |
12582 | 340 if (x11_get_property(XA_NET_SUPPORTED, &args, &nitems)) |
341 { | |
342 mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports NetWM.\n"); | |
343 for (i = 0; i < nitems; i++) | |
344 wm |= net_wm_support_state_test(args[i]); | |
345 XFree(args); | |
346 } | |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
347 |
12582 | 348 if (wm == 0) |
349 mp_msg(MSGT_VO, MSGL_V, "[x11] Unknown wm type...\n"); | |
350 return wm; | |
351 } | |
6009 | 352 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
353 static void init_atoms(void) |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
354 { |
12582 | 355 XA_INIT(_NET_SUPPORTED); |
356 XA_INIT(_NET_WM_STATE); | |
357 XA_INIT(_NET_WM_STATE_FULLSCREEN); | |
358 XA_INIT(_NET_WM_STATE_ABOVE); | |
359 XA_INIT(_NET_WM_STATE_STAYS_ON_TOP); | |
360 XA_INIT(_NET_WM_STATE_BELOW); | |
361 XA_INIT(_NET_WM_PID); | |
362 XA_INIT(_WIN_PROTOCOLS); | |
363 XA_INIT(_WIN_LAYER); | |
364 XA_INIT(_WIN_HINTS); | |
18149
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
365 XA_INIT(WM_PROTOCOLS); |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
366 XA_INIT(WM_DELETE_WINDOW); |
8742
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
367 } |
241f40ef5e28
More fullscreen cleanup work. Use nice macros for X atoms.
filon
parents:
8716
diff
changeset
|
368 |
18116 | 369 void update_xinerama_info(void) { |
26436 | 370 xinerama_x = xinerama_y = 0; |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
371 #ifdef CONFIG_XINERAMA |
31061
075a2c6bebb4
Move variable declaration into the block where it is actually used.
reimar
parents:
31058
diff
changeset
|
372 if (xinerama_screen >= -1 && XineramaIsActive(mDisplay)) |
18116 | 373 { |
31061
075a2c6bebb4
Move variable declaration into the block where it is actually used.
reimar
parents:
31058
diff
changeset
|
374 int screen = xinerama_screen; |
18116 | 375 XineramaScreenInfo *screens; |
376 int num_screens; | |
377 | |
378 screens = XineramaQueryScreens(mDisplay, &num_screens); | |
26436 | 379 if (screen >= num_screens) |
380 screen = num_screens - 1; | |
381 if (screen == -1) { | |
382 int x = vo_dx + vo_dwidth / 2; | |
383 int y = vo_dy + vo_dheight / 2; | |
384 for (screen = num_screens - 1; screen > 0; screen--) { | |
385 int left = screens[screen].x_org; | |
386 int right = left + screens[screen].width; | |
387 int top = screens[screen].y_org; | |
388 int bottom = top + screens[screen].height; | |
389 if (left <= x && x <= right && top <= y && y <= bottom) | |
390 break; | |
391 } | |
26407 | 392 } |
18116 | 393 if (screen < 0) |
394 screen = 0; | |
395 vo_screenwidth = screens[screen].width; | |
396 vo_screenheight = screens[screen].height; | |
397 xinerama_x = screens[screen].x_org; | |
398 xinerama_y = screens[screen].y_org; | |
399 | |
400 XFree(screens); | |
401 } | |
18160
03bc3385a845
10l, aspect_save_screenres must be always called in update_xinerama_info.
reimar
parents:
18149
diff
changeset
|
402 #endif |
18116 | 403 aspect_save_screenres(vo_screenwidth, vo_screenheight); |
404 } | |
405 | |
12582 | 406 int vo_init(void) |
32 | 407 { |
922
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
408 // int mScreen; |
12582 | 409 int depth, bpp; |
410 unsigned int mask; | |
411 | |
412 XImage *mXImage = NULL; | |
413 | |
922
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
414 // Window mRootWin; |
12582 | 415 XWindowAttributes attribs; |
416 char *dispName; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
417 |
31536 | 418 if (vo_rootwin) |
419 WinID = 0; // use root window | |
32 | 420 |
12582 | 421 if (vo_depthonscreen) |
13935 | 422 { |
423 saver_off(mDisplay); | |
12582 | 424 return 1; // already called |
13935 | 425 } |
32 | 426 |
12582 | 427 XSetErrorHandler(x11_errorhandler); |
4812 | 428 |
12582 | 429 dispName = XDisplayName(mDisplayName); |
4812 | 430 |
12582 | 431 mp_msg(MSGT_VO, MSGL_V, "X11 opening display: %s\n", dispName); |
922
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
432 |
12582 | 433 mDisplay = XOpenDisplay(dispName); |
434 if (!mDisplay) | |
435 { | |
436 mp_msg(MSGT_VO, MSGL_ERR, | |
437 "vo: couldn't open the X11 display (%s)!\n", dispName); | |
438 return 0; | |
439 } | |
21938 | 440 mScreen = DefaultScreen(mDisplay); // screen ID |
441 mRootWin = RootWindow(mDisplay, mScreen); // root window ID | |
2149
6358db6ad3d0
Xinerama screen size fix by Lev Babiev <harley@hosers.org>
arpi
parents:
1746
diff
changeset
|
442 |
12582 | 443 init_atoms(); |
444 | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
445 #ifdef CONFIG_XF86VM |
12582 | 446 { |
447 int clock; | |
448 | |
449 XF86VidModeGetModeLine(mDisplay, mScreen, &clock, &modeline); | |
450 if (!vo_screenwidth) | |
451 vo_screenwidth = modeline.hdisplay; | |
452 if (!vo_screenheight) | |
453 vo_screenheight = modeline.vdisplay; | |
454 } | |
4977
7b65a4f0b74e
vm pecs applied from daniel carter <hedonist@win.co.nz>
pontscho
parents:
4974
diff
changeset
|
455 #endif |
12582 | 456 { |
457 if (!vo_screenwidth) | |
458 vo_screenwidth = DisplayWidth(mDisplay, mScreen); | |
459 if (!vo_screenheight) | |
460 vo_screenheight = DisplayHeight(mDisplay, mScreen); | |
461 } | |
462 // get color depth (from root window, or the best visual): | |
463 XGetWindowAttributes(mDisplay, mRootWin, &attribs); | |
464 depth = attribs.depth; | |
1732 | 465 |
12582 | 466 if (depth != 15 && depth != 16 && depth != 24 && depth != 32) |
467 { | |
468 Visual *visual; | |
469 | |
470 depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual); | |
471 if (depth != -1) | |
472 mXImage = XCreateImage(mDisplay, visual, depth, ZPixmap, | |
473 0, NULL, 1, 1, 8, 1); | |
474 } else | |
475 mXImage = | |
476 XGetImage(mDisplay, mRootWin, 0, 0, 1, 1, AllPlanes, ZPixmap); | |
1732 | 477 |
12582 | 478 vo_depthonscreen = depth; // display depth on screen |
1732 | 479 |
12582 | 480 // get bits/pixel from XImage structure: |
481 if (mXImage == NULL) | |
482 { | |
483 mask = 0; | |
484 } else | |
485 { | |
486 /* | |
487 * for the depth==24 case, the XImage structures might use | |
488 * 24 or 32 bits of data per pixel. The global variable | |
489 * vo_depthonscreen stores the amount of data per pixel in the | |
490 * XImage structure! | |
491 * | |
492 * Maybe we should rename vo_depthonscreen to (or add) vo_bpp? | |
493 */ | |
494 bpp = mXImage->bits_per_pixel; | |
495 if ((vo_depthonscreen + 7) / 8 != (bpp + 7) / 8) | |
496 vo_depthonscreen = bpp; // by A'rpi | |
497 mask = | |
498 mXImage->red_mask | mXImage->green_mask | mXImage->blue_mask; | |
499 mp_msg(MSGT_VO, MSGL_V, | |
500 "vo: X11 color mask: %X (R:%lX G:%lX B:%lX)\n", mask, | |
501 mXImage->red_mask, mXImage->green_mask, mXImage->blue_mask); | |
502 XDestroyImage(mXImage); | |
503 } | |
504 if (((vo_depthonscreen + 7) / 8) == 2) | |
505 { | |
506 if (mask == 0x7FFF) | |
507 vo_depthonscreen = 15; | |
508 else if (mask == 0xFFFF) | |
509 vo_depthonscreen = 16; | |
510 } | |
922
db06ae8967eb
Centralized and cleaned up X11 connecting, fixed remote X11 playing, -display option for mplayer. SHOULD BE TESTED.
lgb
parents:
741
diff
changeset
|
511 // XCloseDisplay( mDisplay ); |
1447
e82fbd67ae60
better local display connection patch by Adam Tla/lka atlka@pg.gda.pl
arpi
parents:
1415
diff
changeset
|
512 /* slightly improved local display detection AST */ |
12582 | 513 if (strncmp(dispName, "unix:", 5) == 0) |
514 dispName += 4; | |
515 else if (strncmp(dispName, "localhost:", 10) == 0) | |
516 dispName += 9; | |
517 if (*dispName == ':' && atoi(dispName + 1) < 10) | |
518 mLocalDisplay = 1; | |
519 else | |
520 mLocalDisplay = 0; | |
16301 | 521 mp_msg(MSGT_VO, MSGL_V, |
12582 | 522 "vo: X11 running at %dx%d with depth %d and %d bpp (\"%s\" => %s display)\n", |
523 vo_screenwidth, vo_screenheight, depth, vo_depthonscreen, | |
524 dispName, mLocalDisplay ? "local" : "remote"); | |
5997
b5fb9a927bf3
add WM detection, and wm specific fullscreen code. (???)
pontscho
parents:
5981
diff
changeset
|
525 |
12582 | 526 vo_wm_type = vo_wm_detect(); |
527 | |
528 vo_fs_type = vo_x11_get_fs_type(vo_wm_type); | |
5997
b5fb9a927bf3
add WM detection, and wm specific fullscreen code. (???)
pontscho
parents:
5981
diff
changeset
|
529 |
12582 | 530 fstype_dump(vo_fs_type); |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
531 |
12582 | 532 saver_off(mDisplay); |
533 return 1; | |
32 | 534 } |
535 | |
12582 | 536 void vo_uninit(void) |
6013
7f6e02a16ac4
some bugfix, x[11|mga|v] ( fullscreen with more files )
pontscho
parents:
6009
diff
changeset
|
537 { |
12582 | 538 if (!mDisplay) |
539 { | |
540 mp_msg(MSGT_VO, MSGL_V, | |
25962 | 541 "vo: x11 uninit called but X11 not initialized..\n"); |
12582 | 542 return; |
543 } | |
6077 | 544 // if( !vo_depthonscreen ) return; |
12582 | 545 mp_msg(MSGT_VO, MSGL_V, "vo: uninit ...\n"); |
546 XSetErrorHandler(NULL); | |
547 XCloseDisplay(mDisplay); | |
548 vo_depthonscreen = 0; | |
549 mDisplay = NULL; | |
6013
7f6e02a16ac4
some bugfix, x[11|mga|v] ( fullscreen with more files )
pontscho
parents:
6009
diff
changeset
|
550 } |
4436 | 551 |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
12972
diff
changeset
|
552 #include "osdep/keycodes.h" |
32 | 553 #include "wskeys.h" |
554 | |
9822
1e761763566c
Support for "internet" or "multimedia" keyboards in X11.
albeu
parents:
9695
diff
changeset
|
555 #ifdef XF86XK_AudioPause |
31017 | 556 static const struct mp_keymap keysym_map[] = { |
28137
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
557 {XF86XK_MenuKB, KEY_MENU}, |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
558 {XF86XK_AudioPlay, KEY_PLAY}, {XF86XK_AudioPause, KEY_PAUSE}, {XF86XK_AudioStop, KEY_STOP}, |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
559 {XF86XK_AudioPrev, KEY_PREV}, {XF86XK_AudioNext, KEY_NEXT}, |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
560 {XF86XK_AudioMute, KEY_MUTE}, {XF86XK_AudioLowerVolume, KEY_VOLUME_DOWN}, {XF86XK_AudioRaiseVolume, KEY_VOLUME_UP}, |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
561 {0, 0} |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
562 }; |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
563 |
18950 | 564 static void vo_x11_putkey_ext(int keysym) |
12582 | 565 { |
28137
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
566 int mpkey = lookup_keymap_table(keysym_map, keysym); |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
567 if (mpkey) |
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
568 mplayer_put_key(mpkey); |
9822
1e761763566c
Support for "internet" or "multimedia" keyboards in X11.
albeu
parents:
9695
diff
changeset
|
569 } |
1e761763566c
Support for "internet" or "multimedia" keyboards in X11.
albeu
parents:
9695
diff
changeset
|
570 #endif |
1e761763566c
Support for "internet" or "multimedia" keyboards in X11.
albeu
parents:
9695
diff
changeset
|
571 |
31017 | 572 static const struct mp_keymap keymap[] = { |
28135 | 573 // special keys |
33521
8966911e5233
Allow Pause/Break key to be bound as MPlayer input key under X11.
diego
parents:
33462
diff
changeset
|
574 {wsPause, KEY_PAUSE}, {wsEscape, KEY_ESC}, {wsBackSpace, KEY_BS}, |
8966911e5233
Allow Pause/Break key to be bound as MPlayer input key under X11.
diego
parents:
33462
diff
changeset
|
575 {wsTab, KEY_TAB}, {wsEnter, KEY_ENTER}, |
28135 | 576 |
577 // cursor keys | |
578 {wsLeft, KEY_LEFT}, {wsRight, KEY_RIGHT}, {wsUp, KEY_UP}, {wsDown, KEY_DOWN}, | |
579 | |
580 // navigation block | |
581 {wsInsert, KEY_INSERT}, {wsDelete, KEY_DELETE}, {wsHome, KEY_HOME}, {wsEnd, KEY_END}, | |
582 {wsPageUp, KEY_PAGE_UP}, {wsPageDown, KEY_PAGE_DOWN}, | |
583 | |
584 // F-keys | |
585 {wsF1, KEY_F+1}, {wsF2, KEY_F+2}, {wsF3, KEY_F+3}, {wsF4, KEY_F+4}, | |
586 {wsF5, KEY_F+5}, {wsF6, KEY_F+6}, {wsF7, KEY_F+7}, {wsF8, KEY_F+8}, | |
587 {wsF9, KEY_F+9}, {wsF10, KEY_F+10}, {wsF11, KEY_F+11}, {wsF12, KEY_F+12}, | |
588 | |
589 // numpad independent of numlock | |
590 {wsGrayMinus, '-'}, {wsGrayPlus, '+'}, {wsGrayMul, '*'}, {wsGrayDiv, '/'}, | |
591 {wsGrayEnter, KEY_KPENTER}, | |
592 | |
593 // numpad with numlock | |
594 {wsGray0, KEY_KP0}, {wsGray1, KEY_KP1}, {wsGray2, KEY_KP2}, | |
595 {wsGray3, KEY_KP3}, {wsGray4, KEY_KP4}, {wsGray5, KEY_KP5}, | |
596 {wsGray6, KEY_KP6}, {wsGray7, KEY_KP7}, {wsGray8, KEY_KP8}, | |
597 {wsGray9, KEY_KP9}, {wsGrayDecimal, KEY_KPDEC}, | |
598 | |
599 // numpad without numlock | |
600 {wsGrayInsert, KEY_KPINS}, {wsGrayEnd, KEY_KP1}, {wsGrayDown, KEY_KP2}, | |
601 {wsGrayPgDn, KEY_KP3}, {wsGrayLeft, KEY_KP4}, {wsGray5Dup, KEY_KP5}, | |
602 {wsGrayRight, KEY_KP6}, {wsGrayHome, KEY_KP7}, {wsGrayUp, KEY_KP8}, | |
603 {wsGrayPgUp, KEY_KP9}, {wsGrayDelete, KEY_KPDEL}, | |
604 | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
605 {0, 0} |
28135 | 606 }; |
607 | |
12582 | 608 void vo_x11_putkey(int key) |
609 { | |
28133
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
610 static const char *passthrough_keys = " -+*/<>`~!@#$%^&()_{}:;\"\',.?\\|=[]"; |
28135 | 611 int mpkey = 0; |
28133
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
612 if ((key >= 'a' && key <= 'z') || |
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
613 (key >= 'A' && key <= 'Z') || |
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
614 (key >= '0' && key <= '9') || |
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
615 (key > 0 && key < 256 && strchr(passthrough_keys, key))) |
28135 | 616 mpkey = key; |
28133
272238675b78
Simplify handling of X11 key events that are just passed through.
reimar
parents:
28063
diff
changeset
|
617 |
28137
28bf0d126da2
Add and use a special lookup function to do table-based translation to MPlayer keycodes.
reimar
parents:
28135
diff
changeset
|
618 if (!mpkey) |
28140
49dadf7bd73a
100l, forgot an assignment, broke special keys handling for X11-based vos.
reimar
parents:
28137
diff
changeset
|
619 mpkey = lookup_keymap_table(keymap, key); |
369 | 620 |
28135 | 621 if (mpkey) |
622 mplayer_put_key(mpkey); | |
32 | 623 } |
624 | |
625 | |
626 // ----- Motif header: ------- | |
627 | |
1236 | 628 #define MWM_HINTS_FUNCTIONS (1L << 0) |
629 #define MWM_HINTS_DECORATIONS (1L << 1) | |
630 #define MWM_HINTS_INPUT_MODE (1L << 2) | |
631 #define MWM_HINTS_STATUS (1L << 3) | |
632 | |
633 #define MWM_FUNC_ALL (1L << 0) | |
634 #define MWM_FUNC_RESIZE (1L << 1) | |
635 #define MWM_FUNC_MOVE (1L << 2) | |
636 #define MWM_FUNC_MINIMIZE (1L << 3) | |
637 #define MWM_FUNC_MAXIMIZE (1L << 4) | |
638 #define MWM_FUNC_CLOSE (1L << 5) | |
639 | |
640 #define MWM_DECOR_ALL (1L << 0) | |
641 #define MWM_DECOR_BORDER (1L << 1) | |
642 #define MWM_DECOR_RESIZEH (1L << 2) | |
643 #define MWM_DECOR_TITLE (1L << 3) | |
644 #define MWM_DECOR_MENU (1L << 4) | |
645 #define MWM_DECOR_MINIMIZE (1L << 5) | |
646 #define MWM_DECOR_MAXIMIZE (1L << 6) | |
647 | |
648 #define MWM_INPUT_MODELESS 0 | |
649 #define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1 | |
650 #define MWM_INPUT_SYSTEM_MODAL 2 | |
651 #define MWM_INPUT_FULL_APPLICATION_MODAL 3 | |
652 #define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL | |
653 | |
654 #define MWM_TEAROFF_WINDOW (1L<<0) | |
32 | 655 |
656 typedef struct | |
657 { | |
12582 | 658 long flags; |
659 long functions; | |
660 long decorations; | |
661 long input_mode; | |
662 long state; | |
32 | 663 } MotifWmHints; |
664 | |
12582 | 665 static MotifWmHints vo_MotifWmHints; |
666 static Atom vo_MotifHints = None; | |
32 | 667 |
12582 | 668 void vo_x11_decoration(Display * vo_Display, Window w, int d) |
32 | 669 { |
12582 | 670 static unsigned int olddecor = MWM_DECOR_ALL; |
671 static unsigned int oldfuncs = | |
672 MWM_FUNC_MOVE | MWM_FUNC_CLOSE | MWM_FUNC_MINIMIZE | | |
673 MWM_FUNC_MAXIMIZE | MWM_FUNC_RESIZE; | |
674 Atom mtype; | |
675 int mformat; | |
676 unsigned long mn, mb; | |
677 | |
678 if (!WinID) | |
679 return; | |
5955
caac20b1ca79
fix xmga fs, resize to movie size and mouse auto hide + dga
pontscho
parents:
5919
diff
changeset
|
680 |
12582 | 681 if (vo_fsmode & 8) |
682 { | |
683 XSetTransientForHint(vo_Display, w, | |
684 RootWindow(vo_Display, mScreen)); | |
685 } | |
686 | |
687 vo_MotifHints = XInternAtom(vo_Display, "_MOTIF_WM_HINTS", 0); | |
688 if (vo_MotifHints != None) | |
689 { | |
690 if (!d) | |
691 { | |
692 MotifWmHints *mhints = NULL; | |
1415 | 693 |
12582 | 694 XGetWindowProperty(vo_Display, w, vo_MotifHints, 0, 20, False, |
695 vo_MotifHints, &mtype, &mformat, &mn, | |
696 &mb, (unsigned char **) &mhints); | |
697 if (mhints) | |
698 { | |
699 if (mhints->flags & MWM_HINTS_DECORATIONS) | |
700 olddecor = mhints->decorations; | |
701 if (mhints->flags & MWM_HINTS_FUNCTIONS) | |
702 oldfuncs = mhints->functions; | |
703 XFree(mhints); | |
704 } | |
705 } | |
12096 | 706 |
12582 | 707 memset(&vo_MotifWmHints, 0, sizeof(MotifWmHints)); |
708 vo_MotifWmHints.flags = | |
709 MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS; | |
710 if (d) | |
711 { | |
712 vo_MotifWmHints.functions = oldfuncs; | |
713 d = olddecor; | |
714 } | |
4993 | 715 #if 0 |
12582 | 716 vo_MotifWmHints.decorations = |
717 d | ((vo_fsmode & 2) ? 0 : MWM_DECOR_MENU); | |
4993 | 718 #else |
12582 | 719 vo_MotifWmHints.decorations = |
720 d | ((vo_fsmode & 2) ? MWM_DECOR_MENU : 0); | |
4993 | 721 #endif |
12582 | 722 XChangeProperty(vo_Display, w, vo_MotifHints, vo_MotifHints, 32, |
723 PropModeReplace, | |
724 (unsigned char *) &vo_MotifWmHints, | |
725 (vo_fsmode & 4) ? 4 : 5); | |
726 } | |
32 | 727 } |
728 | |
30083
8375205ecdcc
vo_x11_classhint name argument should be const, since we pass string constants there.
reimar
parents:
29862
diff
changeset
|
729 void vo_x11_classhint(Display * display, Window window, const char *name) |
12582 | 730 { |
731 XClassHint wmClass; | |
732 pid_t pid = getpid(); | |
33917
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
733 long prop = pid & 0x7FFFFFFF; |
12582 | 734 |
29862
fbb1f57a313e
Added -name, -title and -use-filename-title options and implementation in X11 vos
ptt
parents:
29776
diff
changeset
|
735 wmClass.res_name = vo_winname ? vo_winname : name; |
12582 | 736 wmClass.res_class = "MPlayer"; |
737 XSetClassHint(display, window, &wmClass); | |
33917
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
738 |
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
739 /* PID sizes other than 32-bit are not handled by the EWMH spec */ |
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
740 if ((pid_t)prop != pid) |
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
741 return; |
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
742 |
12582 | 743 XChangeProperty(display, window, XA_NET_WM_PID, XA_CARDINAL, 32, |
33917
da037b5d9ede
x11_common: XChangeProperty uses long for 32-bits.
cigaes
parents:
33733
diff
changeset
|
744 PropModeReplace, (unsigned char *)&prop, 1); |
1137
4c7b219e126c
patch: some X11 compliance fixed: set ClassHint and better fullscreen mode
arpi_esp
parents:
1109
diff
changeset
|
745 } |
4c7b219e126c
patch: some X11 compliance fixed: set ClassHint and better fullscreen mode
arpi_esp
parents:
1109
diff
changeset
|
746 |
12582 | 747 Window vo_window = None; |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
748 GC vo_gc = None; |
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
749 GC f_gc = None; |
4993 | 750 XSizeHints vo_hint; |
4795 | 751 |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17366
diff
changeset
|
752 void vo_x11_uninit(void) |
4437 | 753 { |
7111 | 754 saver_on(mDisplay); |
12582 | 755 if (vo_window != None) |
756 vo_showcursor(mDisplay, vo_window); | |
4742 | 757 |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
758 if (f_gc != None) |
12582 | 759 { |
760 XFreeGC(mDisplay, f_gc); | |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
761 f_gc = None; |
12582 | 762 } |
4437 | 763 { |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
764 if (vo_gc != None) |
12582 | 765 { |
766 XFreeGC(mDisplay, vo_gc); | |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
767 vo_gc = None; |
12582 | 768 } |
769 if (vo_window != None) | |
770 { | |
771 XClearWindow(mDisplay, vo_window); | |
772 if (WinID < 0) | |
773 { | |
774 XEvent xev; | |
775 | |
776 XUnmapWindow(mDisplay, vo_window); | |
30718
4993c3f12cc0
Enable StructureNotifyMask before waiting for a DestroyNotify event.
reimar
parents:
30556
diff
changeset
|
777 XSelectInput(mDisplay, vo_window, StructureNotifyMask); |
12582 | 778 XDestroyWindow(mDisplay, vo_window); |
779 do | |
780 { | |
781 XNextEvent(mDisplay, &xev); | |
782 } | |
783 while (xev.type != DestroyNotify | |
784 || xev.xdestroywindow.event != vo_window); | |
785 } | |
786 vo_window = None; | |
787 } | |
788 vo_fs = 0; | |
789 vo_old_width = vo_old_height = 0; | |
4437 | 790 } |
791 } | |
792 | |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
793 static unsigned int mouse_timer; |
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
794 static int mouse_waiting_hide; |
5651
b8d8d72776f2
fix playlist bug with gui and rewrite mousecursor show/hide code
pontscho
parents:
5538
diff
changeset
|
795 |
31538 | 796 static int check_resize(void) |
797 { | |
798 int old_w = vo_dwidth, old_h = vo_dheight; | |
32368
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
799 int old_x = vo_dx, old_y = vo_dy; |
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
800 int rc = 0; |
31538 | 801 vo_x11_update_geometry(); |
31606
d48795123d88
100l, only set VO_EVENT_RESIZE on an actual resize, not just for movement.
reimar
parents:
31557
diff
changeset
|
802 if (vo_dwidth != old_w || vo_dheight != old_h) |
32368
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
803 rc |= VO_EVENT_RESIZE; |
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
804 if (vo_dx != old_x || vo_dy != old_y) |
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
805 rc |= VO_EVENT_MOVE; |
ff2204a57cd3
Add VO_EVENT_MOVE which is required for VOs that interact directly
reimar
parents:
31834
diff
changeset
|
806 return rc; |
31538 | 807 } |
808 | |
12582 | 809 int vo_x11_check_events(Display * mydisplay) |
810 { | |
811 int ret = 0; | |
812 XEvent Event; | |
813 char buf[100]; | |
814 KeySym keySym; | |
815 static XComposeStatus stat; | |
5651
b8d8d72776f2
fix playlist bug with gui and rewrite mousecursor show/hide code
pontscho
parents:
5538
diff
changeset
|
816 |
31555 | 817 if (vo_mouse_autohide && mouse_waiting_hide && |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
818 (GetTimerMS() - mouse_timer >= 1000)) { |
12582 | 819 vo_hidecursor(mydisplay, vo_window); |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
820 mouse_waiting_hide = 0; |
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
821 } |
6095 | 822 |
31538 | 823 if (WinID > 0) |
824 ret |= check_resize(); | |
12582 | 825 while (XPending(mydisplay)) |
826 { | |
827 XNextEvent(mydisplay, &Event); | |
27343 | 828 #ifdef CONFIG_GUI |
12582 | 829 if (use_gui) |
830 { | |
33733 | 831 gui(GUI_HANDLE_X_EVENT, &Event); |
12582 | 832 if (vo_window != Event.xany.window) |
833 continue; | |
834 } | |
835 #endif | |
6095 | 836 // printf("\rEvent.type=%X \n",Event.type); |
12582 | 837 switch (Event.type) |
838 { | |
839 case Expose: | |
840 ret |= VO_EVENT_EXPOSE; | |
841 break; | |
842 case ConfigureNotify: | |
843 if (vo_window == None) | |
844 break; | |
31538 | 845 ret |= check_resize(); |
12582 | 846 break; |
847 case KeyPress: | |
848 { | |
849 int key; | |
850 | |
27343 | 851 #ifdef CONFIG_GUI |
14001 | 852 if ( use_gui ) { break; } |
853 #endif | |
854 | |
12582 | 855 XLookupString(&Event.xkey, buf, sizeof(buf), &keySym, |
856 &stat); | |
857 #ifdef XF86XK_AudioPause | |
858 vo_x11_putkey_ext(keySym); | |
859 #endif | |
860 key = | |
861 ((keySym & 0xff00) != | |
862 0 ? ((keySym & 0x00ff) + 256) : (keySym)); | |
863 vo_x11_putkey(key); | |
864 ret |= VO_EVENT_KEYPRESS; | |
865 } | |
866 break; | |
867 case MotionNotify: | |
31049
b40e41324173
Avoid duplicating mouse-movement command-generation code.
reimar
parents:
31047
diff
changeset
|
868 vo_mouse_movement(Event.xmotion.x, Event.xmotion.y); |
19850
4919b3ce8d5e
report to mplayer with a slave command the coordinates of the pointer reported by x11; rescale coordinates to [0,1]x[0,1] range - patch by Jonas Jermann and me
nicodvb
parents:
18950
diff
changeset
|
869 |
12582 | 870 if (vo_mouse_autohide) |
871 { | |
872 vo_showcursor(mydisplay, vo_window); | |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
873 mouse_waiting_hide = 1; |
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
874 mouse_timer = GetTimerMS(); |
12582 | 875 } |
876 break; | |
877 case ButtonPress: | |
878 if (vo_mouse_autohide) | |
879 { | |
880 vo_showcursor(mydisplay, vo_window); | |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
881 mouse_waiting_hide = 1; |
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
882 mouse_timer = GetTimerMS(); |
12582 | 883 } |
27343 | 884 #ifdef CONFIG_GUI |
21938 | 885 // Ignore mouse button 1-3 under GUI. |
12582 | 886 if (use_gui && (Event.xbutton.button >= 1) |
887 && (Event.xbutton.button <= 3)) | |
888 break; | |
889 #endif | |
890 mplayer_put_key((MOUSE_BTN0 + Event.xbutton.button - | |
891 1) | MP_KEY_DOWN); | |
892 break; | |
893 case ButtonRelease: | |
894 if (vo_mouse_autohide) | |
895 { | |
896 vo_showcursor(mydisplay, vo_window); | |
18287
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
897 mouse_waiting_hide = 1; |
292337d09af2
Remove updating of vo_mouse_timer_const from the main loop and also
uau
parents:
18237
diff
changeset
|
898 mouse_timer = GetTimerMS(); |
12582 | 899 } |
27343 | 900 #ifdef CONFIG_GUI |
21938 | 901 // Ignore mouse button 1-3 under GUI. |
12582 | 902 if (use_gui && (Event.xbutton.button >= 1) |
903 && (Event.xbutton.button <= 3)) | |
904 break; | |
905 #endif | |
906 mplayer_put_key(MOUSE_BTN0 + Event.xbutton.button - 1); | |
907 break; | |
908 case PropertyNotify: | |
909 { | |
910 char *name = | |
911 XGetAtomName(mydisplay, Event.xproperty.atom); | |
912 | |
913 if (!name) | |
914 break; | |
915 | |
6046 | 916 // fprintf(stderr,"[ws] PropertyNotify ( 0x%x ) %s ( 0x%x )\n",vo_window,name,Event.xproperty.atom ); |
12582 | 917 |
918 XFree(name); | |
919 } | |
920 break; | |
921 case MapNotify: | |
922 vo_hint.win_gravity = old_gravity; | |
923 XSetWMNormalHints(mDisplay, vo_window, &vo_hint); | |
924 vo_fs_flip = 0; | |
925 break; | |
31122 | 926 case DestroyNotify: |
927 mp_msg(MSGT_VO, MSGL_WARN, "Our window was destroyed, exiting\n"); | |
928 mplayer_put_key(KEY_CLOSE_WIN); | |
929 break; | |
18149
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
930 case ClientMessage: |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
931 if (Event.xclient.message_type == XAWM_PROTOCOLS && |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
932 Event.xclient.data.l[0] == XAWM_DELETE_WINDOW) |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
933 mplayer_put_key(KEY_CLOSE_WIN); |
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
934 break; |
12582 | 935 } |
936 } | |
937 return ret; | |
32 | 938 } |
939 | |
13843 | 940 /** |
941 * \brief sets the size and position of the non-fullscreen window. | |
942 */ | |
943 void vo_x11_nofs_sizepos(int x, int y, int width, int height) | |
944 { | |
24312
716b7751e7ad
Make sure aspect hint is adjusted on aspect change
reimar
parents:
24311
diff
changeset
|
945 vo_x11_sizehint(x, y, width, height, 0); |
13843 | 946 if (vo_fs) { |
947 vo_old_x = x; | |
948 vo_old_y = y; | |
949 vo_old_width = width; | |
950 vo_old_height = height; | |
951 } | |
952 else | |
13871 | 953 { |
31536 | 954 vo_dwidth = width; |
955 vo_dheight = height; | |
956 XMoveResizeWindow(mDisplay, vo_window, x, y, width, height); | |
13871 | 957 } |
13843 | 958 } |
959 | |
12582 | 960 void vo_x11_sizehint(int x, int y, int width, int height, int max) |
4993 | 961 { |
24311
0ff0253c8e00
Cosmetics: set vo_hint.flags at more consistent places (directly before
reimar
parents:
23875
diff
changeset
|
962 vo_hint.flags = 0; |
12582 | 963 if (vo_keepaspect) |
964 { | |
965 vo_hint.flags |= PAspect; | |
966 vo_hint.min_aspect.x = width; | |
967 vo_hint.min_aspect.y = height; | |
968 vo_hint.max_aspect.x = width; | |
969 vo_hint.max_aspect.y = height; | |
970 } | |
8692
604f0cde816c
X11 window aspect patch by Arnaud Boulan <boulan@iie.cnam.fr>
attila
parents:
8676
diff
changeset
|
971 |
24311
0ff0253c8e00
Cosmetics: set vo_hint.flags at more consistent places (directly before
reimar
parents:
23875
diff
changeset
|
972 vo_hint.flags |= PPosition | PSize; |
12582 | 973 vo_hint.x = x; |
974 vo_hint.y = y; | |
975 vo_hint.width = width; | |
976 vo_hint.height = height; | |
977 if (max) | |
978 { | |
24311
0ff0253c8e00
Cosmetics: set vo_hint.flags at more consistent places (directly before
reimar
parents:
23875
diff
changeset
|
979 vo_hint.flags |= PMaxSize; |
12582 | 980 vo_hint.max_width = width; |
981 vo_hint.max_height = height; | |
982 } else | |
983 { | |
984 vo_hint.max_width = 0; | |
985 vo_hint.max_height = 0; | |
986 } | |
11995 | 987 |
21938 | 988 // Set minimum height/width to 4 to avoid off-by-one errors |
989 // and because mga_vid requires a minimal size of 4 pixels. | |
24311
0ff0253c8e00
Cosmetics: set vo_hint.flags at more consistent places (directly before
reimar
parents:
23875
diff
changeset
|
990 vo_hint.flags |= PMinSize; |
12582 | 991 vo_hint.min_width = vo_hint.min_height = 4; |
11995 | 992 |
28063
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
993 // Set the base size. A window manager might display the window |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
994 // size to the user relative to this. |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
995 // Setting these to width/height might be nice, but e.g. fluxbox can't handle it. |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
996 vo_hint.flags |= PBaseSize; |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
997 vo_hint.base_width = 0 /*width*/; |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
998 vo_hint.base_height = 0 /*height*/; |
a318969a4f45
Set the base size window manager hint, otherwise some subtract the minimum
reimar
parents:
27927
diff
changeset
|
999 |
24311
0ff0253c8e00
Cosmetics: set vo_hint.flags at more consistent places (directly before
reimar
parents:
23875
diff
changeset
|
1000 vo_hint.flags |= PWinGravity; |
12582 | 1001 vo_hint.win_gravity = StaticGravity; |
1002 XSetWMNormalHints(mDisplay, vo_window, &vo_hint); | |
4993 | 1003 } |
1004 | |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
1005 static int vo_x11_get_gnome_layer(Display * mDisplay, Window win) |
8866 | 1006 { |
12582 | 1007 Atom type; |
1008 int format; | |
1009 unsigned long nitems; | |
1010 unsigned long bytesafter; | |
1011 unsigned short *args = NULL; | |
8866 | 1012 |
12582 | 1013 if (XGetWindowProperty(mDisplay, win, XA_WIN_LAYER, 0, 16384, |
1014 False, AnyPropertyType, &type, &format, &nitems, | |
1015 &bytesafter, | |
1016 (unsigned char **) &args) == Success | |
1017 && nitems > 0 && args) | |
1018 { | |
1019 mp_msg(MSGT_VO, MSGL_V, "[x11] original window layer is %d.\n", | |
1020 *args); | |
1021 return *args; | |
1022 } | |
1023 return WIN_LAYER_NORMAL; | |
8866 | 1024 } |
1025 | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1026 // |
12582 | 1027 Window vo_x11_create_smooth_window(Display * mDisplay, Window mRoot, |
1028 Visual * vis, int x, int y, | |
1029 unsigned int width, unsigned int height, | |
1030 int depth, Colormap col_map) | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1031 { |
27815
f92271dc5f17
Remove X11 backing store: this is now a useless flag.
ben
parents:
27713
diff
changeset
|
1032 unsigned long xswamask = CWBorderPixel; |
12582 | 1033 XSetWindowAttributes xswa; |
1034 Window ret_win; | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1035 |
12582 | 1036 if (col_map != CopyFromParent) |
1037 { | |
1038 xswa.colormap = col_map; | |
1039 xswamask |= CWColormap; | |
1040 } | |
1041 xswa.background_pixel = 0; | |
1042 xswa.border_pixel = 0; | |
27815
f92271dc5f17
Remove X11 backing store: this is now a useless flag.
ben
parents:
27713
diff
changeset
|
1043 xswa.backing_store = NotUseful; |
12582 | 1044 xswa.bit_gravity = StaticGravity; |
1045 | |
1046 ret_win = | |
33435
f7a492ac8d30
Make vo_x11_create_smooth_window() use its parameter mRoot instead
iive
parents:
33419
diff
changeset
|
1047 XCreateWindow(mDisplay, mRoot, x, y, width, height, 0, depth, |
12582 | 1048 CopyFromParent, vis, xswamask, &xswa); |
18149
163fe5c2577d
Register for window-manager delete window events and quit MPlayer.
reimar
parents:
18116
diff
changeset
|
1049 XSetWMProtocols(mDisplay, ret_win, &XAWM_DELETE_WINDOW, 1); |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
1050 if (f_gc == None) |
12582 | 1051 f_gc = XCreateGC(mDisplay, ret_win, 0, 0); |
1052 XSetForeground(mDisplay, f_gc, 0); | |
1053 | |
1054 return ret_win; | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1055 } |
12582 | 1056 |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1057 /** |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1058 * \brief create and setup a window suitable for display |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1059 * \param vis Visual to use for creating the window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1060 * \param x x position of window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1061 * \param y y position of window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1062 * \param width width of window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1063 * \param height height of window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1064 * \param flags flags for window creation. |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1065 * Only VOFLAG_FULLSCREEN is supported so far. |
23823
513293585949
document "default" behaviour if CopyFromParent is passed as colormap
attila
parents:
23660
diff
changeset
|
1066 * \param col_map Colourmap for window or CopyFromParent if a specific colormap isn't needed |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1067 * \param classname name to use for the classhint |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1068 * \param title title for the window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1069 * |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1070 * This also does the grunt-work like setting Window Manager hints etc. |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1071 * If vo_window is already set it just moves and resizes it. |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1072 */ |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1073 void vo_x11_create_vo_window(XVisualInfo *vis, int x, int y, |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1074 unsigned int width, unsigned int height, int flags, |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1075 Colormap col_map, |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1076 const char *classname, const char *title) |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1077 { |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1078 if (WinID >= 0) { |
29514
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1079 vo_fs = flags & VOFLAG_FULLSCREEN; |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1080 vo_window = WinID ? (Window)WinID : mRootWin; |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1081 if (col_map != CopyFromParent) { |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1082 unsigned long xswamask = CWColormap; |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1083 XSetWindowAttributes xswa; |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1084 xswa.colormap = col_map; |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1085 XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa); |
29572
4890363e713a
Do not do a unmap/map cycle on Windows given with -wid, with some window
reimar
parents:
29514
diff
changeset
|
1086 XInstallColormap(mDisplay, col_map); |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1087 } |
31539
b07ed23358af
Always request expose events, we have to handle them, the application
reimar
parents:
31538
diff
changeset
|
1088 if (WinID) { |
31556 | 1089 // Expose events can only really be handled by us, so request them. |
1090 // Do not remove existing masks so GUI keeps working. | |
1091 XWindowAttributes attribs; | |
1092 XGetWindowAttributes(mDisplay, vo_window, &attribs); | |
1093 vo_x11_selectinput_witherr(mDisplay, vo_window, | |
1094 attribs.your_event_mask | ExposureMask); | |
31539
b07ed23358af
Always request expose events, we have to handle them, the application
reimar
parents:
31538
diff
changeset
|
1095 } else |
31536 | 1096 // Do not capture events since it might break the parent application |
1097 // if it relies on events being forwarded to the parent of WinID. | |
1098 // It also is consistent with the w32_common.c code. | |
1099 vo_x11_selectinput_witherr(mDisplay, vo_window, | |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1100 StructureNotifyMask | KeyPressMask | PointerMotionMask | |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1101 ButtonPressMask | ButtonReleaseMask | ExposureMask); |
31557 | 1102 |
1103 vo_x11_update_geometry(); | |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1104 goto final; |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1105 } |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1106 if (vo_window == None) { |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1107 vo_fs = 0; |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1108 vo_dwidth = width; |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1109 vo_dheight = height; |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1110 vo_window = vo_x11_create_smooth_window(mDisplay, mRootWin, vis->visual, |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1111 x, y, width, height, vis->depth, col_map); |
30465
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1112 window_state = VOFLAG_HIDDEN; |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1113 } |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1114 if (flags & VOFLAG_HIDDEN) |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1115 goto final; |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1116 if (window_state & VOFLAG_HIDDEN) { |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1117 XSizeHints hint; |
3422423f2e20
Create the OpenGL probe window as a hidden Window on X11.
reimar
parents:
30455
diff
changeset
|
1118 XEvent xev; |
30472
ddce1a6f3c59
Fix hang with -fixed-vo due to VOFLAG_HIDDEN never being removed from window_state.
reimar
parents:
30465
diff
changeset
|
1119 window_state &= ~VOFLAG_HIDDEN; |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1120 vo_x11_classhint(mDisplay, vo_window, classname); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1121 XStoreName(mDisplay, vo_window, title); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1122 vo_hidecursor(mDisplay, vo_window); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1123 XSelectInput(mDisplay, vo_window, StructureNotifyMask); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1124 hint.x = x; hint.y = y; |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1125 hint.width = width; hint.height = height; |
31223
4031008a248c
Change code to let Window Manager chose window location by default.
reimar
parents:
31122
diff
changeset
|
1126 hint.flags = PSize; |
4031008a248c
Change code to let Window Manager chose window location by default.
reimar
parents:
31122
diff
changeset
|
1127 if (geometry_xy_changed) |
4031008a248c
Change code to let Window Manager chose window location by default.
reimar
parents:
31122
diff
changeset
|
1128 hint.flags |= PPosition; |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1129 XSetStandardProperties(mDisplay, vo_window, title, title, None, NULL, 0, &hint); |
27304 | 1130 if (!vo_border) vo_x11_decoration(mDisplay, vo_window, 0); |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1131 // map window |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1132 XMapWindow(mDisplay, vo_window); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1133 // wait for map |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1134 do { |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1135 XNextEvent(mDisplay, &xev); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1136 } while (xev.type != MapNotify || xev.xmap.event != vo_window); |
33419 | 1137 vo_x11_clearwindow(mDisplay, vo_window); |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1138 XSelectInput(mDisplay, vo_window, NoEventMask); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1139 XSync(mDisplay, False); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1140 vo_x11_selectinput_witherr(mDisplay, vo_window, |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1141 StructureNotifyMask | KeyPressMask | PointerMotionMask | |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1142 ButtonPressMask | ButtonReleaseMask | ExposureMask); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1143 } |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1144 if (vo_ontop) vo_x11_setlayer(mDisplay, vo_window, vo_ontop); |
31223
4031008a248c
Change code to let Window Manager chose window location by default.
reimar
parents:
31122
diff
changeset
|
1145 if (!geometry_xy_changed) |
4031008a248c
Change code to let Window Manager chose window location by default.
reimar
parents:
31122
diff
changeset
|
1146 vo_x11_update_geometry(); |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1147 vo_x11_nofs_sizepos(vo_dx, vo_dy, width, height); |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1148 if (!!vo_fs != !!(flags & VOFLAG_FULLSCREEN)) |
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1149 vo_x11_fullscreen(); |
28771
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1150 else if (vo_fs) { |
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1151 // if we are already in fullscreen do not switch back and forth, just |
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1152 // set the size values right. |
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1153 vo_dwidth = vo_screenwidth; |
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1154 vo_dheight = vo_screenheight; |
bd24ac0d9fd8
Make sure vo_x11_create_vo_window sets vo_dwidth and vo_dheight right
reimar
parents:
28512
diff
changeset
|
1155 } |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1156 final: |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1157 if (vo_gc != None) |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1158 XFreeGC(mDisplay, vo_gc); |
33437
5b1120ddd033
Create empty vo_gc graphic context instead of one with
iive
parents:
33436
diff
changeset
|
1159 vo_gc = XCreateGC(mDisplay, vo_window, 0, NULL); |
5b1120ddd033
Create empty vo_gc graphic context instead of one with
iive
parents:
33436
diff
changeset
|
1160 |
27927
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1161 XSync(mDisplay, False); |
6f199f065e15
Factor common code like -wid handling, vo_gc creation etc. out into
reimar
parents:
27893
diff
changeset
|
1162 vo_mouse_autohide = 1; |
23655
00aa61cde84a
Make X11 window creation and (with -fixed-vo) management simpler and more
reimar
parents:
23615
diff
changeset
|
1163 } |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1164 |
12582 | 1165 void vo_x11_clearwindow_part(Display * mDisplay, Window vo_window, |
1166 int img_width, int img_height, int use_fs) | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1167 { |
12582 | 1168 int u_dheight, u_dwidth, left_ov, left_ov2; |
10765
c8fb7e2690a3
10000l. Never ever use such foolish GCC 3.x extensionscvs diff -u x11_common.c x11_common.h |more
alex
parents:
10757
diff
changeset
|
1169 |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
1170 if (f_gc == None) |
12582 | 1171 return; |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1172 |
12582 | 1173 u_dheight = use_fs ? vo_screenheight : vo_dheight; |
1174 u_dwidth = use_fs ? vo_screenwidth : vo_dwidth; | |
1175 if ((u_dheight <= img_height) && (u_dwidth <= img_width)) | |
1176 return; | |
10765
c8fb7e2690a3
10000l. Never ever use such foolish GCC 3.x extensionscvs diff -u x11_common.c x11_common.h |more
alex
parents:
10757
diff
changeset
|
1177 |
12582 | 1178 left_ov = (u_dheight - img_height) / 2; |
1179 left_ov2 = (u_dwidth - img_width) / 2; | |
1180 | |
1181 XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, u_dwidth, left_ov); | |
1182 XFillRectangle(mDisplay, vo_window, f_gc, 0, u_dheight - left_ov - 1, | |
1183 u_dwidth, left_ov + 1); | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1184 |
12582 | 1185 if (u_dwidth > img_width) |
1186 { | |
1187 XFillRectangle(mDisplay, vo_window, f_gc, 0, left_ov, left_ov2, | |
1188 img_height); | |
1189 XFillRectangle(mDisplay, vo_window, f_gc, u_dwidth - left_ov2 - 1, | |
23660
3ab096c77b9e
Fix vo_x11_clearwindow_part: x position is one less to avoid not clearing
reimar
parents:
23655
diff
changeset
|
1190 left_ov, left_ov2 + 1, img_height); |
12582 | 1191 } |
1192 | |
1193 XFlush(mDisplay); | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1194 } |
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1195 |
12582 | 1196 void vo_x11_clearwindow(Display * mDisplay, Window vo_window) |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1197 { |
31356
c3e536cf595b
Consistently use "None" instead of "NULL" for X resources.
reimar
parents:
31328
diff
changeset
|
1198 if (f_gc == None) |
12582 | 1199 return; |
1200 XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, vo_screenwidth, | |
1201 vo_screenheight); | |
1202 // | |
1203 XFlush(mDisplay); | |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1204 } |
12582 | 1205 |
10757
3aea64e0d6d9
Avoid flickering during resizes. Keep video contents even when paused. Fix by Tomas Simonaitis <haden@homelan.lt>
mosu
parents:
10754
diff
changeset
|
1206 |
12582 | 1207 void vo_x11_setlayer(Display * mDisplay, Window vo_window, int layer) |
5997
b5fb9a927bf3
add WM detection, and wm specific fullscreen code. (???)
pontscho
parents:
5981
diff
changeset
|
1208 { |
12582 | 1209 if (WinID >= 0) |
1210 return; | |
8864 | 1211 |
12582 | 1212 if (vo_fs_type & vo_wm_LAYER) |
1213 { | |
1214 XClientMessageEvent xev; | |
1215 | |
1216 if (!orig_layer) | |
1217 orig_layer = vo_x11_get_gnome_layer(mDisplay, vo_window); | |
8866 | 1218 |
12582 | 1219 memset(&xev, 0, sizeof(xev)); |
1220 xev.type = ClientMessage; | |
1221 xev.display = mDisplay; | |
1222 xev.window = vo_window; | |
1223 xev.message_type = XA_WIN_LAYER; | |
1224 xev.format = 32; | |
1225 xev.data.l[0] = layer ? fs_layer : orig_layer; // if not fullscreen, stay on default layer | |
1226 xev.data.l[1] = CurrentTime; | |
1227 mp_msg(MSGT_VO, MSGL_V, | |
17366 | 1228 "[x11] Layered style stay on top (layer %ld).\n", |
12582 | 1229 xev.data.l[0]); |
1230 XSendEvent(mDisplay, mRootWin, False, SubstructureNotifyMask, | |
1231 (XEvent *) & xev); | |
1232 } else if (vo_fs_type & vo_wm_NETWM) | |
1233 { | |
1234 XClientMessageEvent xev; | |
1235 char *state; | |
8645 | 1236 |
12582 | 1237 memset(&xev, 0, sizeof(xev)); |
1238 xev.type = ClientMessage; | |
1239 xev.message_type = XA_NET_WM_STATE; | |
1240 xev.display = mDisplay; | |
1241 xev.window = vo_window; | |
1242 xev.format = 32; | |
1243 xev.data.l[0] = layer; | |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1244 |
12582 | 1245 if (vo_fs_type & vo_wm_STAYS_ON_TOP) |
1246 xev.data.l[1] = XA_NET_WM_STATE_STAYS_ON_TOP; | |
1247 else if (vo_fs_type & vo_wm_ABOVE) | |
1248 xev.data.l[1] = XA_NET_WM_STATE_ABOVE; | |
1249 else if (vo_fs_type & vo_wm_FULLSCREEN) | |
1250 xev.data.l[1] = XA_NET_WM_STATE_FULLSCREEN; | |
1251 else if (vo_fs_type & vo_wm_BELOW) | |
21938 | 1252 // This is not fallback. We can safely assume that the situation |
1253 // where only NETWM_STATE_BELOW is supported doesn't exist. | |
12582 | 1254 xev.data.l[1] = XA_NET_WM_STATE_BELOW; |
1255 | |
1256 XSendEvent(mDisplay, mRootWin, False, SubstructureRedirectMask, | |
1257 (XEvent *) & xev); | |
1258 state = XGetAtomName(mDisplay, xev.data.l[1]); | |
1259 mp_msg(MSGT_VO, MSGL_V, | |
1260 "[x11] NET style stay on top (layer %d). Using state %s.\n", | |
1261 layer, state); | |
1262 XFree(state); | |
1263 } | |
5997
b5fb9a927bf3
add WM detection, and wm specific fullscreen code. (???)
pontscho
parents:
5981
diff
changeset
|
1264 } |
b5fb9a927bf3
add WM detection, and wm specific fullscreen code. (???)
pontscho
parents:
5981
diff
changeset
|
1265 |
10587
382bf4771ee7
moved lot of global variables into static ones (and some minor spelling fixes)
alex
parents:
10570
diff
changeset
|
1266 static int vo_x11_get_fs_type(int supported) |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1267 { |
12582 | 1268 int i; |
1269 int type = supported; | |
1270 | |
1271 if (vo_fstype_list) | |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1272 { |
12582 | 1273 for (i = 0; vo_fstype_list[i]; i++) |
1274 { | |
1275 int neg = 0; | |
1276 char *arg = vo_fstype_list[i]; | |
1277 | |
1278 if (vo_fstype_list[i][0] == '-') | |
1279 { | |
1280 neg = 1; | |
1281 arg = vo_fstype_list[i] + 1; | |
1282 } | |
1283 | |
1284 if (!strncmp(arg, "layer", 5)) | |
1285 { | |
1286 if (!neg && (arg[5] == '=')) | |
1287 { | |
1288 char *endptr = NULL; | |
1289 int layer = strtol(vo_fstype_list[i] + 6, &endptr, 10); | |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1290 |
12582 | 1291 if (endptr && *endptr == '\0' && layer >= 0 |
1292 && layer <= 15) | |
1293 fs_layer = layer; | |
1294 } | |
1295 if (neg) | |
1296 type &= ~vo_wm_LAYER; | |
1297 else | |
1298 type |= vo_wm_LAYER; | |
1299 } else if (!strcmp(arg, "above")) | |
1300 { | |
1301 if (neg) | |
1302 type &= ~vo_wm_ABOVE; | |
1303 else | |
1304 type |= vo_wm_ABOVE; | |
1305 } else if (!strcmp(arg, "fullscreen")) | |
1306 { | |
1307 if (neg) | |
1308 type &= ~vo_wm_FULLSCREEN; | |
1309 else | |
1310 type |= vo_wm_FULLSCREEN; | |
1311 } else if (!strcmp(arg, "stays_on_top")) | |
1312 { | |
1313 if (neg) | |
1314 type &= ~vo_wm_STAYS_ON_TOP; | |
1315 else | |
1316 type |= vo_wm_STAYS_ON_TOP; | |
1317 } else if (!strcmp(arg, "below")) | |
1318 { | |
1319 if (neg) | |
1320 type &= ~vo_wm_BELOW; | |
1321 else | |
1322 type |= vo_wm_BELOW; | |
1323 } else if (!strcmp(arg, "netwm")) | |
1324 { | |
1325 if (neg) | |
1326 type &= ~vo_wm_NETWM; | |
1327 else | |
1328 type |= vo_wm_NETWM; | |
1329 } else if (!strcmp(arg, "none")) | |
29763
752432ff3360
Slightly change behavior of "none" if fstype specification.
corey
parents:
29753
diff
changeset
|
1330 type = 0; // clear; keep parsing |
9317
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1331 } |
c7f5df43b937
- support command line parameter -fstype, eg. -fstype layer=12,above,fullscreen
filon
parents:
9217
diff
changeset
|
1332 } |
5919 | 1333 |
12582 | 1334 return type; |
4981 | 1335 } |
1336 | |
27885
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1337 /** |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1338 * \brief update vo_dx, vo_dy, vo_dwidth and vo_dheight with current values of vo_window |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1339 * \return returns current color depth of vo_window |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1340 */ |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1341 int vo_x11_update_geometry(void) { |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1342 unsigned depth, w, h; |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1343 int dummy_int; |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1344 Window dummy_win; |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1345 XGetGeometry(mDisplay, vo_window, &dummy_win, &dummy_int, &dummy_int, |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1346 &w, &h, &dummy_int, &depth); |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1347 if (w <= INT_MAX && h <= INT_MAX) { vo_dwidth = w; vo_dheight = h; } |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1348 XTranslateCoordinates(mDisplay, vo_window, mRootWin, 0, 0, &vo_dx, &vo_dy, |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1349 &dummy_win); |
29862
fbb1f57a313e
Added -name, -title and -use-filename-title options and implementation in X11 vos
ptt
parents:
29776
diff
changeset
|
1350 if (vo_wintitle) |
fbb1f57a313e
Added -name, -title and -use-filename-title options and implementation in X11 vos
ptt
parents:
29776
diff
changeset
|
1351 XStoreName(mDisplay, vo_window, vo_wintitle); |
fbb1f57a313e
Added -name, -title and -use-filename-title options and implementation in X11 vos
ptt
parents:
29776
diff
changeset
|
1352 |
27885
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1353 return depth <= INT_MAX ? depth : 0; |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1354 } |
9829cfa41d6d
Replace some of the different inconsistent XGetGeometry uses by a
reimar
parents:
27815
diff
changeset
|
1355 |
12582 | 1356 void vo_x11_fullscreen(void) |
11542 | 1357 { |
12582 | 1358 int x, y, w, h; |
29753
75f54a9e4160
Move some variable initializations to the beginning of vo_x11_fullscreen().
diego
parents:
29572
diff
changeset
|
1359 x = vo_old_x; |
75f54a9e4160
Move some variable initializations to the beginning of vo_x11_fullscreen().
diego
parents:
29572
diff
changeset
|
1360 y = vo_old_y; |
75f54a9e4160
Move some variable initializations to the beginning of vo_x11_fullscreen().
diego
parents:
29572
diff
changeset
|
1361 w = vo_old_width; |
75f54a9e4160
Move some variable initializations to the beginning of vo_x11_fullscreen().
diego
parents:
29572
diff
changeset
|
1362 h = vo_old_height; |
12582 | 1363 |
29514
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1364 if (WinID >= 0) { |
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1365 vo_fs = !vo_fs; |
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1366 return; |
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1367 } |
23a59bb3baf4
First attempts at supporting -fs with -wid, -vo gl on X11 only so far
reimar
parents:
29332
diff
changeset
|
1368 if (vo_fs_flip) |
12582 | 1369 return; |
1370 | |
1371 if (vo_fs) | |
1372 { | |
33937 | 1373 vo_x11_ewmh_fullscreen(vo_window, _NET_WM_STATE_REMOVE); // removes fullscreen state if wm supports EWMH |
12796
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1374 vo_fs = VO_FALSE; |
12582 | 1375 } else |
1376 { | |
1377 // win->fs | |
33937 | 1378 vo_x11_ewmh_fullscreen(vo_window, _NET_WM_STATE_ADD); // sends fullscreen state to be added if wm supports EWMH |
12582 | 1379 |
12796
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1380 vo_fs = VO_TRUE; |
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1381 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs |
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1382 { |
12798
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1383 vo_old_x = vo_dx; |
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1384 vo_old_y = vo_dy; |
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1385 vo_old_width = vo_dwidth; |
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1386 vo_old_height = vo_dheight; |
23875
df05ff41590e
make sure update_xinerama_info is always called even when using the
reimar
parents:
23823
diff
changeset
|
1387 } |
18116 | 1388 update_xinerama_info(); |
1389 x = xinerama_x; | |
1390 y = xinerama_y; | |
12798
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1391 w = vo_screenwidth; |
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1392 h = vo_screenheight; |
12582 | 1393 } |
1394 { | |
1395 long dummy; | |
1396 | |
1397 XGetWMNormalHints(mDisplay, vo_window, &vo_hint, &dummy); | |
1398 if (!(vo_hint.flags & PWinGravity)) | |
1399 old_gravity = NorthWestGravity; | |
1400 else | |
1401 old_gravity = vo_hint.win_gravity; | |
1402 } | |
1403 if (vo_wm_type == 0 && !(vo_fsmode & 16)) | |
1404 { | |
1405 XUnmapWindow(mDisplay, vo_window); // required for MWM | |
1406 XWithdrawWindow(mDisplay, vo_window, mScreen); | |
1407 vo_fs_flip = 1; | |
1408 } | |
1409 | |
12796
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1410 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs |
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1411 { |
27303
690ba711bda8
Make vo_x11_fullscreen not break vo_border (proper support still needs vo changes)
reimar
parents:
27029
diff
changeset
|
1412 vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs); |
12798
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1413 vo_x11_sizehint(x, y, w, h, 0); |
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1414 vo_x11_setlayer(mDisplay, vo_window, vo_fs); |
12582 | 1415 |
1416 | |
12798
33423862b159
Indentation fix from previous patch, as discussed on IRC.
rtognimp
parents:
12796
diff
changeset
|
1417 XMoveResizeWindow(mDisplay, vo_window, x, y, w, h); |
12796
24075685789b
This fixes the problems that originated from my ewmh
rtognimp
parents:
12582
diff
changeset
|
1418 } |
21938 | 1419 /* some WMs lose ontop after fullscreen */ |
14244
9b03ad0254ae
Fix ontop for some WMs that lose ontop state after fullscreen event.
al
parents:
14207
diff
changeset
|
1420 if ((!(vo_fs)) & vo_ontop) |
9b03ad0254ae
Fix ontop for some WMs that lose ontop state after fullscreen event.
al
parents:
14207
diff
changeset
|
1421 vo_x11_setlayer(mDisplay, vo_window, vo_ontop); |
9b03ad0254ae
Fix ontop for some WMs that lose ontop state after fullscreen event.
al
parents:
14207
diff
changeset
|
1422 |
12582 | 1423 XMapRaised(mDisplay, vo_window); |
18715
30d7ddf08889
Fix window position when changing videos while in fullscreen and for
reimar
parents:
18508
diff
changeset
|
1424 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // some WMs change window pos on map |
30d7ddf08889
Fix window position when changing videos while in fullscreen and for
reimar
parents:
18508
diff
changeset
|
1425 XMoveResizeWindow(mDisplay, vo_window, x, y, w, h); |
12582 | 1426 XRaiseWindow(mDisplay, vo_window); |
1427 XFlush(mDisplay); | |
1428 } | |
1429 | |
1430 void vo_x11_ontop(void) | |
1431 { | |
1432 vo_ontop = (!(vo_ontop)); | |
1433 | |
1434 vo_x11_setlayer(mDisplay, vo_window, vo_ontop); | |
11542 | 1435 } |
1436 | |
27306
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1437 void vo_x11_border(void) |
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1438 { |
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1439 vo_border = !vo_border; |
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1440 vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs); |
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1441 } |
7a650839fc10
Enable runtime border/window decorations-toggling for Linux gl and gl2 vos.
reimar
parents:
27304
diff
changeset
|
1442 |
9695 | 1443 /* |
1444 * XScreensaver stuff | |
1445 */ | |
1446 | |
25608
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1447 static int screensaver_off; |
12031
0c2b8b731d42
Use system clock for xscreensaver pings (Tobias Diedrich).
diego
parents:
11995
diff
changeset
|
1448 static unsigned int time_last; |
9695 | 1449 |
12031
0c2b8b731d42
Use system clock for xscreensaver pings (Tobias Diedrich).
diego
parents:
11995
diff
changeset
|
1450 void xscreensaver_heartbeat(void) |
9695 | 1451 { |
12031
0c2b8b731d42
Use system clock for xscreensaver pings (Tobias Diedrich).
diego
parents:
11995
diff
changeset
|
1452 unsigned int time = GetTimerMS(); |
9695 | 1453 |
25609
dc64735e7391
Remove most of the messy screensaver code in favour of only XResetScreenSaver
reimar
parents:
25608
diff
changeset
|
1454 if (mDisplay && screensaver_off && (time - time_last) > 30000) |
12582 | 1455 { |
1456 time_last = time; | |
9695 | 1457 |
25609
dc64735e7391
Remove most of the messy screensaver code in favour of only XResetScreenSaver
reimar
parents:
25608
diff
changeset
|
1458 XResetScreenSaver(mDisplay); |
9695 | 1459 } |
1460 } | |
1461 | |
25466 | 1462 static int xss_suspend(Bool suspend) |
1463 { | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
1464 #ifndef CONFIG_XSS |
25466 | 1465 return 0; |
1466 #else | |
1467 int event, error, major, minor; | |
1468 if (XScreenSaverQueryExtension(mDisplay, &event, &error) != True || | |
1469 XScreenSaverQueryVersion(mDisplay, &major, &minor) != True) | |
1470 return 0; | |
27029
e8c49e69f46f
Add parentheses to expression to avoid the warning:
diego
parents:
26755
diff
changeset
|
1471 if (major < 1 || (major == 1 && minor < 1)) |
25466 | 1472 return 0; |
1473 XScreenSaverSuspend(mDisplay, suspend); | |
1474 return 1; | |
1475 #endif | |
1476 } | |
1477 | |
9695 | 1478 /* |
1479 * End of XScreensaver stuff | |
1480 */ | |
1481 | |
12582 | 1482 void saver_on(Display * mDisplay) |
1483 { | |
324 | 1484 |
25608
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1485 if (!screensaver_off) |
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1486 return; |
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1487 screensaver_off = 0; |
25466 | 1488 if (xss_suspend(False)) |
1489 return; | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
1490 #ifdef CONFIG_XDPMS |
324 | 1491 if (dpms_disabled) |
1492 { | |
25447 | 1493 int nothing; |
12582 | 1494 if (DPMSQueryExtension(mDisplay, ¬hing, ¬hing)) |
1495 { | |
1496 if (!DPMSEnable(mDisplay)) | |
1497 { // restoring power saving settings | |
1498 mp_msg(MSGT_VO, MSGL_WARN, "DPMS not available?\n"); | |
1499 } else | |
1500 { | |
741 | 1501 // DPMS does not seem to be enabled unless we call DPMSInfo |
12582 | 1502 BOOL onoff; |
1503 CARD16 state; | |
1504 | |
1505 DPMSForceLevel(mDisplay, DPMSModeOn); | |
1506 DPMSInfo(mDisplay, &state, &onoff); | |
1507 if (onoff) | |
1508 { | |
13946 | 1509 mp_msg(MSGT_VO, MSGL_V, |
12582 | 1510 "Successfully enabled DPMS\n"); |
1511 } else | |
1512 { | |
1513 mp_msg(MSGT_VO, MSGL_WARN, "Could not enable DPMS\n"); | |
741 | 1514 } |
1515 } | |
12582 | 1516 } |
1517 dpms_disabled = 0; | |
324 | 1518 } |
1345
be674b95b485
x11_common does not compile, when the XDPMS extension is not available on the
jkeil
parents:
1266
diff
changeset
|
1519 #endif |
324 | 1520 } |
1521 | |
12582 | 1522 void saver_off(Display * mDisplay) |
1523 { | |
1345
be674b95b485
x11_common does not compile, when the XDPMS extension is not available on the
jkeil
parents:
1266
diff
changeset
|
1524 int nothing; |
324 | 1525 |
33986
90a73d713bb2
Make the stop-xscreensaver option behave as described in the man page.
reimar
parents:
33966
diff
changeset
|
1526 if (!stop_xscreensaver || screensaver_off) |
25608
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1527 return; |
3ada48a71450
Use a screensaver_off variable to save current state and avoid
reimar
parents:
25482
diff
changeset
|
1528 screensaver_off = 1; |
25466 | 1529 if (xss_suspend(True)) |
1530 return; | |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
1531 #ifdef CONFIG_XDPMS |
324 | 1532 if (DPMSQueryExtension(mDisplay, ¬hing, ¬hing)) |
1533 { | |
12582 | 1534 BOOL onoff; |
1535 CARD16 state; | |
1536 | |
1537 DPMSInfo(mDisplay, &state, &onoff); | |
1538 if (onoff) | |
1539 { | |
1540 Status stat; | |
1541 | |
13946 | 1542 mp_msg(MSGT_VO, MSGL_V, "Disabling DPMS\n"); |
12582 | 1543 dpms_disabled = 1; |
1544 stat = DPMSDisable(mDisplay); // monitor powersave off | |
1545 mp_msg(MSGT_VO, MSGL_V, "DPMSDisable stat: %d\n", stat); | |
1546 } | |
324 | 1547 } |
1345
be674b95b485
x11_common does not compile, when the XDPMS extension is not available on the
jkeil
parents:
1266
diff
changeset
|
1548 #endif |
326 | 1549 } |
448
198b46b739d8
qrva eletbe nem kene cvs-t elbaszni inkabb ne nyuljatok hozza baz+
arpi_esp
parents:
440
diff
changeset
|
1550 |
6953
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1551 static XErrorHandler old_handler = NULL; |
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1552 static int selectinput_err = 0; |
12582 | 1553 static int x11_selectinput_errorhandler(Display * display, |
1554 XErrorEvent * event) | |
6953
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1555 { |
12582 | 1556 if (event->error_code == BadAccess) |
1557 { | |
1558 selectinput_err = 1; | |
1559 mp_msg(MSGT_VO, MSGL_ERR, | |
1560 "X11 error: BadAccess during XSelectInput Call\n"); | |
1561 mp_msg(MSGT_VO, MSGL_ERR, | |
1562 "X11 error: The 'ButtonPressMask' mask of specified window has probably already used by another appication (see man XSelectInput)\n"); | |
21938 | 1563 /* If you think MPlayer should shutdown with this error, |
1564 * comment out the following line */ | |
12582 | 1565 return 0; |
1566 } | |
1567 if (old_handler != NULL) | |
1568 old_handler(display, event); | |
1569 else | |
1570 x11_errorhandler(display, event); | |
1571 return 0; | |
6953
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1572 } |
3990 | 1573 |
12582 | 1574 void vo_x11_selectinput_witherr(Display * display, Window w, |
1575 long event_mask) | |
6953
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1576 { |
12582 | 1577 XSync(display, False); |
1578 old_handler = XSetErrorHandler(x11_selectinput_errorhandler); | |
1579 selectinput_err = 0; | |
1580 if (vo_nomouse_input) | |
1581 { | |
1582 XSelectInput(display, w, | |
1583 event_mask & | |
1584 (~(ButtonPressMask | ButtonReleaseMask))); | |
1585 } else | |
1586 { | |
1587 XSelectInput(display, w, event_mask); | |
1588 } | |
1589 XSync(display, False); | |
1590 XSetErrorHandler(old_handler); | |
1591 if (selectinput_err) | |
1592 { | |
1593 mp_msg(MSGT_VO, MSGL_ERR, | |
1594 "X11 error: MPlayer discards mouse control (reconfiguring)\n"); | |
1595 XSelectInput(display, w, | |
1596 event_mask & | |
1597 (~ | |
1598 (ButtonPressMask | ButtonReleaseMask | | |
1599 PointerMotionMask))); | |
1600 } | |
6953
ce67cc1f0beb
ignore BadAccess error at XSelectInput() (grabbing mouse etc) with warning
arpi
parents:
6401
diff
changeset
|
1601 } |
3990 | 1602 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
1603 #ifdef CONFIG_XF86VM |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1604 void vo_vm_switch(void) |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1605 { |
13828
b4ad5f0b550d
Fix erroneus extern declarations, fix wrong signedness of some vars
atmos4
parents:
13787
diff
changeset
|
1606 int vm_event, vm_error; |
b4ad5f0b550d
Fix erroneus extern declarations, fix wrong signedness of some vars
atmos4
parents:
13787
diff
changeset
|
1607 int vm_ver, vm_rev; |
12582 | 1608 int i, j, have_vm = 0; |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1609 int X = vo_dwidth, Y = vo_dheight; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1610 int modeline_width, modeline_height; |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1611 |
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1612 int modecount; |
12582 | 1613 |
1614 if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error)) | |
1615 { | |
1616 XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev); | |
18508 | 1617 mp_msg(MSGT_VO, MSGL_V, "XF86VidMode extension v%i.%i\n", vm_ver, |
12582 | 1618 vm_rev); |
1619 have_vm = 1; | |
27887
47385b5c0613
Set modeline_width/height to sane values in vo_vm_switch even when
reimar
parents:
27885
diff
changeset
|
1620 } else { |
12582 | 1621 mp_msg(MSGT_VO, MSGL_WARN, |
18508 | 1622 "XF86VidMode extension not available.\n"); |
27887
47385b5c0613
Set modeline_width/height to sane values in vo_vm_switch even when
reimar
parents:
27885
diff
changeset
|
1623 } |
12582 | 1624 |
1625 if (have_vm) | |
1626 { | |
1627 if (vidmodes == NULL) | |
1628 XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount, | |
1629 &vidmodes); | |
1630 j = 0; | |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1631 modeline_width = vidmodes[0]->hdisplay; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1632 modeline_height = vidmodes[0]->vdisplay; |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1633 |
12582 | 1634 for (i = 1; i < modecount; i++) |
1635 if ((vidmodes[i]->hdisplay >= X) | |
1636 && (vidmodes[i]->vdisplay >= Y)) | |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1637 if ((vidmodes[i]->hdisplay <= modeline_width) |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1638 && (vidmodes[i]->vdisplay <= modeline_height)) |
12582 | 1639 { |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1640 modeline_width = vidmodes[i]->hdisplay; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1641 modeline_height = vidmodes[i]->vdisplay; |
12582 | 1642 j = i; |
1643 } | |
1644 | |
16793
8d4fb5469efb
Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents:
16301
diff
changeset
|
1645 mp_msg(MSGT_VO, MSGL_INFO, MSGTR_SelectedVideoMode, |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1646 modeline_width, modeline_height, X, Y); |
12582 | 1647 XF86VidModeLockModeSwitch(mDisplay, mScreen, 0); |
1648 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]); | |
1649 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]); | |
27889
08a5ccceb21a
Set modified window position and monitor aspect in vo_vm_switch instead of in
reimar
parents:
27887
diff
changeset
|
1650 |
08a5ccceb21a
Set modified window position and monitor aspect in vo_vm_switch instead of in
reimar
parents:
27887
diff
changeset
|
1651 // FIXME: all this is more of a hack than proper solution |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1652 X = (vo_screenwidth - modeline_width) / 2; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1653 Y = (vo_screenheight - modeline_height) / 2; |
12582 | 1654 XF86VidModeSetViewPort(mDisplay, mScreen, X, Y); |
27889
08a5ccceb21a
Set modified window position and monitor aspect in vo_vm_switch instead of in
reimar
parents:
27887
diff
changeset
|
1655 vo_dx = X; |
08a5ccceb21a
Set modified window position and monitor aspect in vo_vm_switch instead of in
reimar
parents:
27887
diff
changeset
|
1656 vo_dy = Y; |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1657 vo_dwidth = modeline_width; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1658 vo_dheight = modeline_height; |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1659 aspect_save_screenres(modeline_width, modeline_height); |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1660 } |
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1661 } |
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1662 |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1663 void vo_vm_close(void) |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1664 { |
12582 | 1665 if (vidmodes != NULL) |
1666 { | |
1667 int i, modecount; | |
5019 | 1668 |
12582 | 1669 free(vidmodes); |
1670 vidmodes = NULL; | |
1671 XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount, | |
1672 &vidmodes); | |
1673 for (i = 0; i < modecount; i++) | |
1674 if ((vidmodes[i]->hdisplay == vo_screenwidth) | |
1675 && (vidmodes[i]->vdisplay == vo_screenheight)) | |
1676 { | |
1677 mp_msg(MSGT_VO, MSGL_INFO, | |
1678 "Returning to original mode %dx%d\n", | |
1679 vo_screenwidth, vo_screenheight); | |
1680 break; | |
1681 } | |
5019 | 1682 |
27890
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1683 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]); |
a4e2700e9381
Simplify vo_vm_switch and vo_vm_close, everyone was using the (almost) same
reimar
parents:
27889
diff
changeset
|
1684 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]); |
12582 | 1685 free(vidmodes); |
1686 vidmodes = NULL; | |
1687 } | |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1688 } |
3990 | 1689 #endif |
4425
6144f63cbaa1
common -vm code, patch by Santi Bjar <tiarda@yahoo.es>
arpi
parents:
4181
diff
changeset
|
1690 |
12582 | 1691 #endif /* X11_FULLSCREEN */ |
7256
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1692 |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1693 |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1694 /* |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1695 * Scan the available visuals on this Display/Screen. Try to find |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1696 * the 'best' available TrueColor visual that has a decent color |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1697 * depth (at least 15bit). If there are multiple visuals with depth |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1698 * >= 15bit, we prefer visuals with a smaller color depth. |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1699 */ |
12582 | 1700 int vo_find_depth_from_visuals(Display * dpy, int screen, |
1701 Visual ** visual_return) | |
7256
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1702 { |
12582 | 1703 XVisualInfo visual_tmpl; |
1704 XVisualInfo *visuals; | |
1705 int nvisuals, i; | |
1706 int bestvisual = -1; | |
1707 int bestvisual_depth = -1; | |
7256
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1708 |
12582 | 1709 visual_tmpl.screen = screen; |
1710 visual_tmpl.class = TrueColor; | |
1711 visuals = XGetVisualInfo(dpy, | |
1712 VisualScreenMask | VisualClassMask, | |
1713 &visual_tmpl, &nvisuals); | |
1714 if (visuals != NULL) | |
1715 { | |
1716 for (i = 0; i < nvisuals; i++) | |
1717 { | |
1718 mp_msg(MSGT_VO, MSGL_V, | |
17366 | 1719 "vo: X11 truecolor visual %#lx, depth %d, R:%lX G:%lX B:%lX\n", |
12582 | 1720 visuals[i].visualid, visuals[i].depth, |
1721 visuals[i].red_mask, visuals[i].green_mask, | |
1722 visuals[i].blue_mask); | |
1723 /* | |
21938 | 1724 * Save the visual index and its depth, if this is the first |
12582 | 1725 * truecolor visul, or a visual that is 'preferred' over the |
21938 | 1726 * previous 'best' visual. |
12582 | 1727 */ |
1728 if (bestvisual_depth == -1 | |
1729 || (visuals[i].depth >= 15 | |
1730 && (visuals[i].depth < bestvisual_depth | |
1731 || bestvisual_depth < 15))) | |
1732 { | |
1733 bestvisual = i; | |
1734 bestvisual_depth = visuals[i].depth; | |
1735 } | |
1736 } | |
1737 | |
1738 if (bestvisual != -1 && visual_return != NULL) | |
1739 *visual_return = visuals[bestvisual].visual; | |
1740 | |
1741 XFree(visuals); | |
7256
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1742 } |
12582 | 1743 return bestvisual_depth; |
7256
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1744 } |
ec6dd0a29d93
Add the code that chooses a good X11 truecolor visual to the vo_x11 config()
jkeil
parents:
7111
diff
changeset
|
1745 |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1746 |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1747 static Colormap cmap = None; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1748 static XColor cols[256]; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1749 static int cm_size, red_mask, green_mask, blue_mask; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1750 |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1751 |
12582 | 1752 Colormap vo_x11_create_colormap(XVisualInfo * vinfo) |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1753 { |
12582 | 1754 unsigned k, r, g, b, ru, gu, bu, m, rv, gv, bv, rvu, gvu, bvu; |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1755 |
12582 | 1756 if (vinfo->class != DirectColor) |
1757 return XCreateColormap(mDisplay, mRootWin, vinfo->visual, | |
1758 AllocNone); | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1759 |
12582 | 1760 /* can this function get called twice or more? */ |
1761 if (cmap) | |
1762 return cmap; | |
1763 cm_size = vinfo->colormap_size; | |
1764 red_mask = vinfo->red_mask; | |
1765 green_mask = vinfo->green_mask; | |
1766 blue_mask = vinfo->blue_mask; | |
1767 ru = (red_mask & (red_mask - 1)) ^ red_mask; | |
1768 gu = (green_mask & (green_mask - 1)) ^ green_mask; | |
1769 bu = (blue_mask & (blue_mask - 1)) ^ blue_mask; | |
1770 rvu = 65536ull * ru / (red_mask + ru); | |
1771 gvu = 65536ull * gu / (green_mask + gu); | |
1772 bvu = 65536ull * bu / (blue_mask + bu); | |
1773 r = g = b = 0; | |
1774 rv = gv = bv = 0; | |
1775 m = DoRed | DoGreen | DoBlue; | |
1776 for (k = 0; k < cm_size; k++) | |
1777 { | |
1778 int t; | |
1779 | |
1780 cols[k].pixel = r | g | b; | |
1781 cols[k].red = rv; | |
1782 cols[k].green = gv; | |
1783 cols[k].blue = bv; | |
1784 cols[k].flags = m; | |
1785 t = (r + ru) & red_mask; | |
1786 if (t < r) | |
1787 m &= ~DoRed; | |
1788 r = t; | |
1789 t = (g + gu) & green_mask; | |
1790 if (t < g) | |
1791 m &= ~DoGreen; | |
1792 g = t; | |
1793 t = (b + bu) & blue_mask; | |
1794 if (t < b) | |
1795 m &= ~DoBlue; | |
1796 b = t; | |
1797 rv += rvu; | |
1798 gv += gvu; | |
1799 bv += bvu; | |
1800 } | |
1801 cmap = XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocAll); | |
1802 XStoreColors(mDisplay, cmap, cols, cm_size); | |
1803 return cmap; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1804 } |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1805 |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1806 /* |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1807 * Via colormaps/gamma ramps we can do gamma, brightness, contrast, |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1808 * hue and red/green/blue intensity, but we cannot do saturation. |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1809 * Currently only gamma, brightness and contrast are implemented. |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1810 * Is there sufficient interest for hue and/or red/green/blue intensity? |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1811 */ |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1812 /* these values have range [-100,100] and are initially 0 */ |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1813 static int vo_gamma = 0; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1814 static int vo_brightness = 0; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1815 static int vo_contrast = 0; |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1816 |
25674
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1817 static int transform_color(float val, |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1818 float brightness, float contrast, float gamma) { |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1819 float s = pow(val, gamma); |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1820 s = (s - 0.5) * contrast + 0.5; |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1821 s += brightness; |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1822 if (s < 0) |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1823 s = 0; |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1824 if (s > 1) |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1825 s = 1; |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1826 return (unsigned short) (s * 65535); |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1827 } |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1828 |
33313
169a40da4c53
Add "const" to equalizer name argument to avoid compiler warnings.
reimar
parents:
33300
diff
changeset
|
1829 uint32_t vo_x11_set_equalizer(const char *name, int value) |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1830 { |
12582 | 1831 float gamma, brightness, contrast; |
1832 float rf, gf, bf; | |
1833 int k; | |
1834 | |
1835 /* | |
1836 * IMPLEMENTME: consider using XF86VidModeSetGammaRamp in the case | |
1837 * of TrueColor-ed window but be careful: | |
21938 | 1838 * Unlike the colormaps, which are private for the X client |
12582 | 1839 * who created them and thus automatically destroyed on client |
1840 * disconnect, this gamma ramp is a system-wide (X-server-wide) | |
21938 | 1841 * setting and _must_ be restored before the process exits. |
1842 * Unforunately when the process crashes (or gets killed | |
12582 | 1843 * for some reason) it is impossible to restore the setting, |
1844 * and such behaviour could be rather annoying for the users. | |
1845 */ | |
1846 if (cmap == None) | |
1847 return VO_NOTAVAIL; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1848 |
12582 | 1849 if (!strcasecmp(name, "brightness")) |
1850 vo_brightness = value; | |
1851 else if (!strcasecmp(name, "contrast")) | |
1852 vo_contrast = value; | |
1853 else if (!strcasecmp(name, "gamma")) | |
1854 vo_gamma = value; | |
1855 else | |
1856 return VO_NOTIMPL; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1857 |
12582 | 1858 brightness = 0.01 * vo_brightness; |
1859 contrast = tan(0.0095 * (vo_contrast + 100) * M_PI / 4); | |
1860 gamma = pow(2, -0.02 * vo_gamma); | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1861 |
12582 | 1862 rf = (float) ((red_mask & (red_mask - 1)) ^ red_mask) / red_mask; |
1863 gf = (float) ((green_mask & (green_mask - 1)) ^ green_mask) / | |
1864 green_mask; | |
1865 bf = (float) ((blue_mask & (blue_mask - 1)) ^ blue_mask) / blue_mask; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1866 |
12582 | 1867 /* now recalculate the colormap using the newly set value */ |
1868 for (k = 0; k < cm_size; k++) | |
1869 { | |
25674
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1870 cols[k].red = transform_color(rf * k, brightness, contrast, gamma); |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1871 cols[k].green = transform_color(gf * k, brightness, contrast, gamma); |
b13f792efe7b
Use a transform_color function to reduce code duplication
reimar
parents:
25626
diff
changeset
|
1872 cols[k].blue = transform_color(bf * k, brightness, contrast, gamma); |
12582 | 1873 } |
1874 | |
1875 XStoreColors(mDisplay, cmap, cols, cm_size); | |
1876 XFlush(mDisplay); | |
1877 return VO_TRUE; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1878 } |
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1879 |
33313
169a40da4c53
Add "const" to equalizer name argument to avoid compiler warnings.
reimar
parents:
33300
diff
changeset
|
1880 uint32_t vo_x11_get_equalizer(const char *name, int *value) |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1881 { |
12582 | 1882 if (cmap == None) |
1883 return VO_NOTAVAIL; | |
1884 if (!strcasecmp(name, "brightness")) | |
1885 *value = vo_brightness; | |
1886 else if (!strcasecmp(name, "contrast")) | |
1887 *value = vo_contrast; | |
1888 else if (!strcasecmp(name, "gamma")) | |
1889 *value = vo_gamma; | |
1890 else | |
1891 return VO_NOTIMPL; | |
1892 return VO_TRUE; | |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1893 } |
12582 | 1894 |
27377
d58d06eafe83
Change a bunch of X11-specific preprocessor directives.
diego
parents:
27343
diff
changeset
|
1895 #ifdef CONFIG_XV |
33300
c7ebb0b711a6
Make vo_xv_set/get_eq() functions expect "const char *" for attribute name.
iive
parents:
32368
diff
changeset
|
1896 int vo_xv_set_eq(uint32_t xv_port, const char *name, int value) |
10359 | 1897 { |
1898 XvAttribute *attributes; | |
12582 | 1899 int i, howmany, xv_atom; |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1900 |
10359 | 1901 mp_dbg(MSGT_VO, MSGL_V, "xv_set_eq called! (%s, %d)\n", name, value); |
7964
143d730908ae
here is a somewhat generic equalizer implementation for the X11 vo drivers
arpi
parents:
7766
diff
changeset
|
1902 |
10359 | 1903 /* get available attributes */ |
1904 attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany); | |
1905 for (i = 0; i < howmany && attributes; i++) | |
12582 | 1906 if (attributes[i].flags & XvSettable) |
1907 { | |
1908 xv_atom = XInternAtom(mDisplay, attributes[i].name, True); | |
10359 | 1909 /* since we have SET_DEFAULTS first in our list, we can check if it's available |
1910 then trigger it if it's ok so that the other values are at default upon query */ | |
12582 | 1911 if (xv_atom != None) |
1912 { | |
1913 int hue = 0, port_value, port_min, port_max; | |
10359 | 1914 |
12582 | 1915 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") && |
1916 (!strcasecmp(name, "brightness"))) | |
1917 port_value = value; | |
1918 else if (!strcmp(attributes[i].name, "XV_CONTRAST") && | |
1919 (!strcasecmp(name, "contrast"))) | |
1920 port_value = value; | |
1921 else if (!strcmp(attributes[i].name, "XV_SATURATION") && | |
1922 (!strcasecmp(name, "saturation"))) | |
1923 port_value = value; | |
1924 else if (!strcmp(attributes[i].name, "XV_HUE") && | |
1925 (!strcasecmp(name, "hue"))) | |
1926 { | |
1927 port_value = value; | |
1928 hue = 1; | |
1929 } else | |
10359 | 1930 /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */ |
12582 | 1931 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") && |
1932 (!strcasecmp(name, "red_intensity"))) | |
1933 port_value = value; | |
1934 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY") | |
1935 && (!strcasecmp(name, "green_intensity"))) | |
1936 port_value = value; | |
1937 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY") | |
1938 && (!strcasecmp(name, "blue_intensity"))) | |
1939 port_value = value; | |
1940 else | |
1941 continue; | |
1942 | |
1943 port_min = attributes[i].min_value; | |
1944 port_max = attributes[i].max_value; | |
10359 | 1945 |
12582 | 1946 /* nvidia hue workaround */ |
1947 if (hue && port_min == 0 && port_max == 360) | |
1948 { | |
1949 port_value = | |
1950 (port_value >= | |
1951 0) ? (port_value - 100) : (port_value + 100); | |
10359 | 1952 } |
12582 | 1953 // -100 -> min |
1954 // 0 -> (max+min)/2 | |
1955 // +100 -> max | |
1956 port_value = | |
1957 (port_value + 100) * (port_max - port_min) / 200 + | |
1958 port_min; | |
1959 XvSetPortAttribute(mDisplay, xv_port, xv_atom, port_value); | |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
1960 return VO_TRUE; |
12582 | 1961 } |
1962 } | |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
1963 return VO_FALSE; |
10359 | 1964 } |
1965 | |
33300
c7ebb0b711a6
Make vo_xv_set/get_eq() functions expect "const char *" for attribute name.
iive
parents:
32368
diff
changeset
|
1966 int vo_xv_get_eq(uint32_t xv_port, const char *name, int *value) |
10359 | 1967 { |
12582 | 1968 |
10359 | 1969 XvAttribute *attributes; |
12582 | 1970 int i, howmany, xv_atom; |
10359 | 1971 |
1972 /* get available attributes */ | |
1973 attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany); | |
1974 for (i = 0; i < howmany && attributes; i++) | |
12582 | 1975 if (attributes[i].flags & XvGettable) |
1976 { | |
1977 xv_atom = XInternAtom(mDisplay, attributes[i].name, True); | |
10359 | 1978 /* since we have SET_DEFAULTS first in our list, we can check if it's available |
1979 then trigger it if it's ok so that the other values are at default upon query */ | |
12582 | 1980 if (xv_atom != None) |
1981 { | |
1982 int val, port_value = 0, port_min, port_max; | |
10359 | 1983 |
12582 | 1984 XvGetPortAttribute(mDisplay, xv_port, xv_atom, |
1985 &port_value); | |
1986 | |
1987 port_min = attributes[i].min_value; | |
1988 port_max = attributes[i].max_value; | |
1989 val = | |
1990 (port_value - port_min) * 200 / (port_max - port_min) - | |
1991 100; | |
10359 | 1992 |
12582 | 1993 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") && |
1994 (!strcasecmp(name, "brightness"))) | |
1995 *value = val; | |
1996 else if (!strcmp(attributes[i].name, "XV_CONTRAST") && | |
1997 (!strcasecmp(name, "contrast"))) | |
1998 *value = val; | |
1999 else if (!strcmp(attributes[i].name, "XV_SATURATION") && | |
2000 (!strcasecmp(name, "saturation"))) | |
2001 *value = val; | |
2002 else if (!strcmp(attributes[i].name, "XV_HUE") && | |
2003 (!strcasecmp(name, "hue"))) | |
2004 { | |
2005 /* nasty nvidia detect */ | |
2006 if (port_min == 0 && port_max == 360) | |
2007 *value = (val >= 0) ? (val - 100) : (val + 100); | |
2008 else | |
2009 *value = val; | |
2010 } else | |
10359 | 2011 /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */ |
12582 | 2012 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") && |
2013 (!strcasecmp(name, "red_intensity"))) | |
2014 *value = val; | |
2015 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY") | |
2016 && (!strcasecmp(name, "green_intensity"))) | |
2017 *value = val; | |
2018 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY") | |
2019 && (!strcasecmp(name, "blue_intensity"))) | |
2020 *value = val; | |
2021 else | |
2022 continue; | |
10359 | 2023 |
12582 | 2024 mp_dbg(MSGT_VO, MSGL_V, "xv_get_eq called! (%s, %d)\n", |
2025 name, *value); | |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
2026 return VO_TRUE; |
12582 | 2027 } |
2028 } | |
26755
46f0b4d34fa1
cosmetics: Remove useless parentheses from from return statements.
diego
parents:
26436
diff
changeset
|
2029 return VO_FALSE; |
10359 | 2030 } |
2031 | |
14742 | 2032 /** \brief contains flags changing the execution of the colorkeying code */ |
2033 xv_ck_info_t xv_ck_info = { CK_METHOD_MANUALFILL, CK_SRC_CUR }; | |
2034 unsigned long xv_colorkey; ///< The color used for manual colorkeying. | |
2035 unsigned int xv_port; ///< The selected Xv port. | |
2036 | |
2037 /** | |
2038 * \brief Interns the requested atom if it is available. | |
2039 * | |
2040 * \param atom_name String containing the name of the requested atom. | |
2041 * | |
2042 * \return Returns the atom if available, else None is returned. | |
2043 * | |
2044 */ | |
2045 static Atom xv_intern_atom_if_exists( char const * atom_name ) | |
2046 { | |
2047 XvAttribute * attributes; | |
2048 int attrib_count,i; | |
2049 Atom xv_atom = None; | |
2050 | |
2051 attributes = XvQueryPortAttributes( mDisplay, xv_port, &attrib_count ); | |
2052 if( attributes!=NULL ) | |
2053 { | |
2054 for ( i = 0; i < attrib_count; ++i ) | |
2055 { | |
2056 if ( strcmp(attributes[i].name, atom_name ) == 0 ) | |
2057 { | |
2058 xv_atom = XInternAtom( mDisplay, atom_name, False ); | |
2059 break; // found what we want, break out | |
2060 } | |
2061 } | |
2062 XFree( attributes ); | |
2063 } | |
2064 | |
2065 return xv_atom; | |
2066 } | |
15826
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2067 |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2068 /** |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2069 * \brief Try to enable vsync for xv. |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2070 * \return Returns -1 if not available, 0 on failure and 1 on success. |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2071 */ |
22886 | 2072 int vo_xv_enable_vsync(void) |
15826
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2073 { |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2074 Atom xv_atom = xv_intern_atom_if_exists("XV_SYNC_TO_VBLANK"); |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2075 if (xv_atom == None) |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2076 return -1; |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2077 return XvSetPortAttribute(mDisplay, xv_port, xv_atom, 1) == Success; |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2078 } |
db966bdf6f5b
Try to set XV_SYNC_TO_VBLANK to enable vsync on non-overlay xv adapters.
reimar
parents:
15789
diff
changeset
|
2079 |
14742 | 2080 /** |
16958 | 2081 * \brief Get maximum supported source image dimensions. |
2082 * | |
2083 * This function does not set the variables pointed to by | |
21938 | 2084 * width and height if the information could not be retrieved, |
2085 * so the caller is reponsible for properly initializing them. | |
16958 | 2086 * |
2087 * \param width [out] The maximum width gets stored here. | |
2088 * \param height [out] The maximum height gets stored here. | |
2089 * | |
2090 */ | |
2091 void vo_xv_get_max_img_dim( uint32_t * width, uint32_t * height ) | |
2092 { | |
2093 XvEncodingInfo * encodings; | |
2094 //unsigned long num_encodings, idx; to int or too long?! | |
2095 unsigned int num_encodings, idx; | |
2096 | |
2097 XvQueryEncodings( mDisplay, xv_port, &num_encodings, &encodings); | |
2098 | |
2099 if ( encodings ) | |
2100 { | |
2101 for ( idx = 0; idx < num_encodings; ++idx ) | |
2102 { | |
2103 if ( strcmp( encodings[idx].name, "XV_IMAGE" ) == 0 ) | |
2104 { | |
2105 *width = encodings[idx].width; | |
2106 *height = encodings[idx].height; | |
2107 break; | |
2108 } | |
2109 } | |
2110 } | |
2111 | |
2112 mp_msg( MSGT_VO, MSGL_V, | |
2113 "[xv common] Maximum source image dimensions: %ux%u\n", | |
2114 *width, *height ); | |
2115 | |
2116 XvFreeEncodingInfo( encodings ); | |
2117 } | |
2118 | |
2119 /** | |
14742 | 2120 * \brief Print information about the colorkey method and source. |
2121 * | |
2122 * \param ck_handling Integer value containing the information about | |
2123 * colorkey handling (see x11_common.h). | |
2124 * | |
2125 * Outputs the content of |ck_handling| as a readable message. | |
2126 * | |
2127 */ | |
30556
358ac046eccc
libvo: Mark functions not used outside of their files as static.
diego
parents:
30516
diff
changeset
|
2128 static void vo_xv_print_ck_info(void) |
14742 | 2129 { |
2130 mp_msg( MSGT_VO, MSGL_V, "[xv common] " ); | |
2131 | |
2132 switch ( xv_ck_info.method ) | |
2133 { | |
2134 case CK_METHOD_NONE: | |
2135 mp_msg( MSGT_VO, MSGL_V, "Drawing no colorkey.\n" ); return; | |
2136 case CK_METHOD_AUTOPAINT: | |
2137 mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn by Xv." ); break; | |
2138 case CK_METHOD_MANUALFILL: | |
2139 mp_msg( MSGT_VO, MSGL_V, "Drawing colorkey manually." ); break; | |
2140 case CK_METHOD_BACKGROUND: | |
2141 mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn as window background." ); break; | |
2142 } | |
2143 | |
2144 mp_msg( MSGT_VO, MSGL_V, "\n[xv common] " ); | |
2145 | |
2146 switch ( xv_ck_info.source ) | |
2147 { | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2148 case CK_SRC_CUR: |
17366 | 2149 mp_msg( MSGT_VO, MSGL_V, "Using colorkey from Xv (0x%06lx).\n", |
14742 | 2150 xv_colorkey ); |
2151 break; | |
2152 case CK_SRC_USE: | |
2153 if ( xv_ck_info.method == CK_METHOD_AUTOPAINT ) | |
2154 { | |
2155 mp_msg( MSGT_VO, MSGL_V, | |
17366 | 2156 "Ignoring colorkey from MPlayer (0x%06lx).\n", |
14742 | 2157 xv_colorkey ); |
2158 } | |
2159 else | |
2160 { | |
2161 mp_msg( MSGT_VO, MSGL_V, | |
17366 | 2162 "Using colorkey from MPlayer (0x%06lx)." |
14742 | 2163 " Use -colorkey to change.\n", |
2164 xv_colorkey ); | |
2165 } | |
2166 break; | |
2167 case CK_SRC_SET: | |
2168 mp_msg( MSGT_VO, MSGL_V, | |
17366 | 2169 "Setting and using colorkey from MPlayer (0x%06lx)." |
14742 | 2170 " Use -colorkey to change.\n", |
2171 xv_colorkey ); | |
2172 break; | |
2173 } | |
2174 } | |
2175 /** | |
2176 * \brief Init colorkey depending on the settings in xv_ck_info. | |
2177 * | |
2178 * \return Returns 0 on failure and 1 on success. | |
2179 * | |
2180 * Sets the colorkey variable according to the CK_SRC_* and CK_METHOD_* | |
2181 * flags in xv_ck_info. | |
2182 * | |
2183 * Possiblilities: | |
2184 * * Methods | |
2185 * - manual colorkey drawing ( CK_METHOD_MANUALFILL ) | |
2186 * - set colorkey as window background ( CK_METHOD_BACKGROUND ) | |
2187 * - let Xv paint the colorkey ( CK_METHOD_AUTOPAINT ) | |
2188 * * Sources | |
2189 * - use currently set colorkey ( CK_SRC_CUR ) | |
2190 * - use colorkey in vo_colorkey ( CK_SRC_USE ) | |
2191 * - use and set colorkey in vo_colorkey ( CK_SRC_SET ) | |
2192 * | |
2193 * NOTE: If vo_colorkey has bits set after the first 3 low order bytes | |
2194 * we don't draw anything as this means it was forced to off. | |
2195 */ | |
22886 | 2196 int vo_xv_init_colorkey(void) |
14742 | 2197 { |
2198 Atom xv_atom; | |
2199 int rez; | |
2200 | |
2201 /* check if colorkeying is needed */ | |
2202 xv_atom = xv_intern_atom_if_exists( "XV_COLORKEY" ); | |
2203 | |
2204 /* if we have to deal with colorkeying ... */ | |
2205 if( xv_atom != None && !(vo_colorkey & 0xFF000000) ) | |
2206 { | |
2207 /* check if we should use the colorkey specified in vo_colorkey */ | |
2208 if ( xv_ck_info.source != CK_SRC_CUR ) | |
2209 { | |
2210 xv_colorkey = vo_colorkey; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2211 |
14742 | 2212 /* check if we have to set the colorkey too */ |
2213 if ( xv_ck_info.source == CK_SRC_SET ) | |
2214 { | |
2215 xv_atom = XInternAtom(mDisplay, "XV_COLORKEY",False); | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2216 |
14742 | 2217 rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, vo_colorkey ); |
2218 if ( rez != Success ) | |
2219 { | |
2220 mp_msg( MSGT_VO, MSGL_FATAL, | |
2221 "[xv common] Couldn't set colorkey!\n" ); | |
2222 return 0; // error setting colorkey | |
2223 } | |
2224 } | |
2225 } | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2226 else |
14742 | 2227 { |
2228 int colorkey_ret; | |
2229 | |
2230 rez=XvGetPortAttribute(mDisplay,xv_port, xv_atom, &colorkey_ret); | |
2231 if ( rez == Success ) | |
2232 { | |
2233 xv_colorkey = colorkey_ret; | |
2234 } | |
2235 else | |
2236 { | |
2237 mp_msg( MSGT_VO, MSGL_FATAL, | |
2238 "[xv common] Couldn't get colorkey!" | |
2239 "Maybe the selected Xv port has no overlay.\n" ); | |
2240 return 0; // error getting colorkey | |
2241 } | |
2242 } | |
2243 | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2244 xv_atom = xv_intern_atom_if_exists( "XV_AUTOPAINT_COLORKEY" ); |
15186 | 2245 |
14742 | 2246 /* should we draw the colorkey ourselves or activate autopainting? */ |
2247 if ( xv_ck_info.method == CK_METHOD_AUTOPAINT ) | |
2248 { | |
2249 rez = !Success; // reset rez to something different than Success | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2250 |
14742 | 2251 if ( xv_atom != None ) // autopaint is supported |
2252 { | |
2253 rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, 1 ); | |
2254 } | |
2255 | |
2256 if ( rez != Success ) | |
2257 { | |
2258 // fallback to manual colorkey drawing | |
2259 xv_ck_info.method = CK_METHOD_MANUALFILL; | |
2260 } | |
2261 } | |
15186 | 2262 else // disable colorkey autopainting if supported |
2263 { | |
2264 if ( xv_atom != None ) // we have autopaint attribute | |
2265 { | |
2266 XvSetPortAttribute( mDisplay, xv_port, xv_atom, 0 ); | |
2267 } | |
2268 } | |
14742 | 2269 } |
2270 else // do no colorkey drawing at all | |
2271 { | |
2272 xv_ck_info.method = CK_METHOD_NONE; | |
2273 } /* end: should we draw colorkey */ | |
2274 | |
21938 | 2275 /* output information about the current colorkey settings */ |
14742 | 2276 vo_xv_print_ck_info(); |
2277 | |
2278 return 1; // success | |
2279 } | |
2280 | |
2281 /** | |
2282 * \brief Draw the colorkey on the video window. | |
2283 * | |
2284 * Draws the colorkey depending on the set method ( colorkey_handling ). | |
2285 * | |
21938 | 2286 * Also draws the black bars ( when the video doesn't fit the display in |
2287 * fullscreen ) separately, so they don't overlap with the video area. | |
2288 * It doesn't call XFlush. | |
14742 | 2289 * |
2290 */ | |
24890 | 2291 void vo_xv_draw_colorkey( int32_t x, int32_t y, |
15100 | 2292 int32_t w, int32_t h ) |
14742 | 2293 { |
15100 | 2294 if( xv_ck_info.method == CK_METHOD_MANUALFILL || |
2295 xv_ck_info.method == CK_METHOD_BACKGROUND )//less tearing than XClearWindow() | |
14742 | 2296 { |
2297 XSetForeground( mDisplay, vo_gc, xv_colorkey ); | |
2298 XFillRectangle( mDisplay, vo_window, vo_gc, | |
2299 x, y, | |
2300 w, h ); | |
2301 } | |
2302 | |
2303 /* draw black bars if needed */ | |
15100 | 2304 /* TODO! move this to vo_x11_clearwindow_part() */ |
14742 | 2305 if ( vo_fs ) |
2306 { | |
2307 XSetForeground( mDisplay, vo_gc, 0 ); | |
21938 | 2308 /* making non-overlap fills, requires 8 checks instead of 4 */ |
14742 | 2309 if ( y > 0 ) |
2310 XFillRectangle( mDisplay, vo_window, vo_gc, | |
2311 0, 0, | |
2312 vo_screenwidth, y); | |
2313 if (x > 0) | |
2314 XFillRectangle( mDisplay, vo_window, vo_gc, | |
15100 | 2315 0, 0, |
2316 x, vo_screenheight); | |
14742 | 2317 if (x + w < vo_screenwidth) |
2318 XFillRectangle( mDisplay, vo_window, vo_gc, | |
15100 | 2319 x + w, 0, |
2320 vo_screenwidth, vo_screenheight); | |
14742 | 2321 if (y + h < vo_screenheight) |
2322 XFillRectangle( mDisplay, vo_window, vo_gc, | |
2323 0, y + h, | |
15100 | 2324 vo_screenwidth, vo_screenheight); |
14742 | 2325 } |
2326 } | |
2327 | |
21938 | 2328 /** \brief Tests if a valid argument for the ck suboption was given. */ |
14742 | 2329 int xv_test_ck( void * arg ) |
2330 { | |
2331 strarg_t * strarg = (strarg_t *)arg; | |
2332 | |
15734
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2333 if ( strargcmp( strarg, "use" ) == 0 || |
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2334 strargcmp( strarg, "set" ) == 0 || |
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2335 strargcmp( strarg, "cur" ) == 0 ) |
14742 | 2336 { |
2337 return 1; | |
2338 } | |
2339 | |
2340 return 0; | |
2341 } | |
21938 | 2342 /** \brief Tests if a valid arguments for the ck-method suboption was given. */ |
14742 | 2343 int xv_test_ckm( void * arg ) |
2344 { | |
2345 strarg_t * strarg = (strarg_t *)arg; | |
2346 | |
15734
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2347 if ( strargcmp( strarg, "bg" ) == 0 || |
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2348 strargcmp( strarg, "man" ) == 0 || |
7e4fa8fc255c
helper functions for comparing strarg_t "strings".
reimar
parents:
15186
diff
changeset
|
2349 strargcmp( strarg, "auto" ) == 0 ) |
14742 | 2350 { |
2351 return 1; | |
2352 } | |
2353 | |
2354 return 0; | |
2355 } | |
2356 | |
2357 /** | |
2358 * \brief Modify the colorkey_handling var according to str | |
2359 * | |
2360 * Checks if a valid pointer ( not NULL ) to the string | |
2361 * was given. And in that case modifies the colorkey_handling | |
2362 * var to reflect the requested behaviour. | |
2363 * If nothing happens the content of colorkey_handling stays | |
2364 * the same. | |
2365 * | |
2366 * \param str Pointer to the string or NULL | |
2367 * | |
2368 */ | |
2369 void xv_setup_colorkeyhandling( char const * ck_method_str, | |
2370 char const * ck_str ) | |
2371 { | |
2372 /* check if a valid pointer to the string was passed */ | |
2373 if ( ck_str ) | |
2374 { | |
2375 if ( strncmp( ck_str, "use", 3 ) == 0 ) | |
2376 { | |
2377 xv_ck_info.source = CK_SRC_USE; | |
2378 } | |
2379 else if ( strncmp( ck_str, "set", 3 ) == 0 ) | |
2380 { | |
2381 xv_ck_info.source = CK_SRC_SET; | |
2382 } | |
2383 } | |
2384 /* check if a valid pointer to the string was passed */ | |
2385 if ( ck_method_str ) | |
2386 { | |
2387 if ( strncmp( ck_method_str, "bg", 2 ) == 0 ) | |
2388 { | |
2389 xv_ck_info.method = CK_METHOD_BACKGROUND; | |
2390 } | |
2391 else if ( strncmp( ck_method_str, "man", 3 ) == 0 ) | |
2392 { | |
2393 xv_ck_info.method = CK_METHOD_MANUALFILL; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2394 } |
14742 | 2395 else if ( strncmp( ck_method_str, "auto", 4 ) == 0 ) |
2396 { | |
2397 xv_ck_info.method = CK_METHOD_AUTOPAINT; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
28771
diff
changeset
|
2398 } |
14742 | 2399 } |
2400 } | |
2401 | |
10359 | 2402 #endif |