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