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