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