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