d78a4ae69a7903c17b924ee05c6c20274292788c
[vlc.git] / modules / video_output / msw / common.c
1 /*****************************************************************************
2  * common.c:
3  *****************************************************************************
4  * Copyright (C) 2001-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24
25 /*****************************************************************************
26  * Preamble: This file contains the functions related to the creation of
27  *             a window and the handling of its messages (events).
28  *****************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32 #include <assert.h>
33
34 #include <vlc_common.h>
35 #include <vlc_vout_display.h>
36 #include <vlc_vout_window.h>
37
38 #include <windows.h>
39 #include <windowsx.h>
40 #include <shellapi.h>
41
42 #ifdef MODULE_NAME_IS_directx
43 #include <ddraw.h>
44 #endif
45 #ifdef MODULE_NAME_IS_direct3d
46 #include <d3d9.h>
47 #endif
48 #ifdef MODULE_NAME_IS_glwin32
49 #include "../opengl.h"
50 #endif
51
52 #include "common.h"
53
54 #ifndef UNDER_CE
55 #include <vlc_windows_interfaces.h>
56 #endif
57
58 #ifdef UNDER_CE
59 #include <aygshell.h>
60     //WINSHELLAPI BOOL WINAPI SHFullScreen(HWND hwndRequester, DWORD dwState);
61 #endif
62
63 static int CommonControlSetFullscreen(vout_display_t *, bool is_fullscreen);
64
65 static void DisableScreensaver(vout_display_t *);
66 static void RestoreScreensaver(vout_display_t *);
67
68 /* */
69 int CommonInit(vout_display_t *vd)
70 {
71     vout_display_sys_t *sys = vd->sys;
72
73     sys->hwnd      = NULL;
74     sys->hvideownd = NULL;
75     sys->hparent   = NULL;
76     sys->hfswnd    = NULL;
77     sys->changes   = 0;
78     SetRectEmpty(&sys->rect_display);
79     SetRectEmpty(&sys->rect_parent);
80     sys->is_first_display = true;
81     sys->is_on_top = false;
82
83     var_Create(vd, "video-title", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
84     var_Create(vd, "video-deco", VLC_VAR_BOOL | VLC_VAR_DOINHERIT);
85
86     /* FIXME remove mouse hide from msw */
87     var_Create(vd, "mouse-hide-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
88
89     /* */
90     sys->event = EventThreadCreate(vd);
91     if (!sys->event)
92         return VLC_EGENERIC;
93
94     event_cfg_t cfg;
95     memset(&cfg, 0, sizeof(cfg));
96 #ifdef MODULE_NAME_IS_direct3d
97     cfg.use_desktop = sys->use_desktop;
98 #endif
99 #ifdef MODULE_NAME_IS_directx
100     cfg.use_overlay = sys->b_using_overlay;
101 #endif
102     cfg.win.type   = VOUT_WINDOW_TYPE_HWND;
103     cfg.win.x      = 0;
104     cfg.win.y      = 0;
105     cfg.win.width  = vd->cfg->display.width;
106     cfg.win.height = vd->cfg->display.height;
107
108     event_hwnd_t hwnd;
109     if (EventThreadStart(sys->event, &hwnd, &cfg))
110         return VLC_EGENERIC;
111
112     sys->parent_window = hwnd.parent_window;
113     sys->hparent       = hwnd.hparent;
114     sys->hwnd          = hwnd.hwnd;
115     sys->hvideownd     = hwnd.hvideownd;
116     sys->hfswnd        = hwnd.hfswnd;
117
118     if (vd->cfg->is_fullscreen) {
119         if (CommonControlSetFullscreen(vd, true))
120             vout_display_SendEventFullscreen(vd, false);
121     }
122
123     /* Why not with glwin32 */
124 #if !defined(UNDER_CE) && !defined(MODULE_NAME_IS_glwin32)
125     var_Create(vd, "disable-screensaver", VLC_VAR_BOOL | VLC_VAR_DOINHERIT);
126     DisableScreensaver (vd);
127 #endif
128
129     return VLC_SUCCESS;
130 }
131
132 /* */
133 void CommonClean(vout_display_t *vd)
134 {
135     vout_display_sys_t *sys = vd->sys;
136
137     if (sys->event) {
138         EventThreadStop(sys->event);
139         EventThreadDestroy(sys->event);
140     }
141
142 #if !defined(UNDER_CE) && !defined(MODULE_NAME_IS_glwin32)
143     RestoreScreensaver(vd);
144 #endif
145 }
146
147 void CommonManage(vout_display_t *vd)
148 {
149     vout_display_sys_t *sys = vd->sys;
150
151     /* We used to call the Win32 PeekMessage function here to read the window
152      * messages. But since window can stay blocked into this function for a
153      * long time (for example when you move your window on the screen), I
154      * decided to isolate PeekMessage in another thread. */
155
156     /* If we do not control our window, we check for geometry changes
157      * ourselves because the parent might not send us its events. */
158     if (sys->hparent) {
159         RECT rect_parent;
160         POINT point;
161
162         GetClientRect(sys->hparent, &rect_parent);
163         point.x = point.y = 0;
164         ClientToScreen(sys->hparent, &point);
165         OffsetRect(&rect_parent, point.x, point.y);
166
167         if (!EqualRect(&rect_parent, &sys->rect_parent)) {
168             sys->rect_parent = rect_parent;
169
170             /* FIXME I find such #ifdef quite weirds. Are they really needed ? */
171
172 #if defined(MODULE_NAME_IS_direct3d)
173             SetWindowPos(sys->hwnd, 0, 0, 0,
174                          rect_parent.right - rect_parent.left,
175                          rect_parent.bottom - rect_parent.top,
176                          SWP_NOZORDER);
177             UpdateRects(vd, NULL, NULL, true);
178 #else
179             /* This one is to force the update even if only
180              * the position has changed */
181             SetWindowPos(sys->hwnd, 0, 1, 1,
182                          rect_parent.right - rect_parent.left,
183                          rect_parent.bottom - rect_parent.top, 0);
184
185             SetWindowPos(sys->hwnd, 0, 0, 0,
186                          rect_parent.right - rect_parent.left,
187                          rect_parent.bottom - rect_parent.top, 0);
188
189 #if defined(MODULE_NAME_IS_wingdi) || defined(MODULE_NAME_IS_wingapi)
190             unsigned int i_x, i_y, i_width, i_height;
191             vout_PlacePicture(vd, rect_parent.right - rect_parent.left,
192                               rect_parent.bottom - rect_parent.top,
193                               &i_x, &i_y, &i_width, &i_height);
194
195             SetWindowPos(sys->hvideownd, HWND_TOP,
196                          i_x, i_y, i_width, i_height, 0);
197 #endif
198 #endif
199         }
200     }
201
202     /* */
203     if (EventThreadGetAndResetHasMoved(sys->event))
204         UpdateRects(vd, NULL, NULL, false);
205
206     /* Pointer change */
207     EventThreadMouseAutoHide(sys->event);
208 }
209
210 /**
211  * It ensures that the video window is shown after the first picture
212  * is displayed.
213  */
214 void CommonDisplay(vout_display_t *vd)
215 {
216     vout_display_sys_t *sys = vd->sys;
217
218     if (!sys->is_first_display)
219         return;
220
221     /* Video window is initially hidden, show it now since we got a
222      * picture to show.
223      */
224     SetWindowPos(sys->hvideownd, 0, 0, 0, 0, 0,
225                  SWP_ASYNCWINDOWPOS|
226                  SWP_FRAMECHANGED|
227                  SWP_SHOWWINDOW|
228                  SWP_NOMOVE|
229                  SWP_NOSIZE|
230                  SWP_NOZORDER);
231     sys->is_first_display = false;
232 }
233
234 /*****************************************************************************
235  * UpdateRects: update clipping rectangles
236  *****************************************************************************
237  * This function is called when the window position or size are changed, and
238  * its job is to update the source and destination RECTs used to display the
239  * picture.
240  *****************************************************************************/
241 void UpdateRects(vout_display_t *vd,
242                   const vout_display_cfg_t *cfg,
243                   const video_format_t *source,
244                   bool is_forced)
245 {
246     vout_display_sys_t *sys = vd->sys;
247 #define rect_src sys->rect_src
248 #define rect_src_clipped sys->rect_src_clipped
249 #define rect_dest sys->rect_dest
250 #define rect_dest_clipped sys->rect_dest_clipped
251
252     RECT  rect;
253     POINT point;
254
255     /* */
256     if (!cfg)
257         cfg = vd->cfg;
258     if (!source)
259         source = &vd->source;
260
261     /* Retrieve the window size */
262     GetClientRect(sys->hwnd, &rect);
263
264     /* Retrieve the window position */
265     point.x = point.y = 0;
266     ClientToScreen(sys->hwnd, &point);
267
268     /* If nothing changed, we can return */
269     bool has_moved;
270     bool is_resized;
271     EventThreadUpdateWindowPosition(sys->event, &has_moved, &is_resized,
272                                     point.x, point.y,
273                                     rect.right, rect.bottom);
274     if (!is_forced && !has_moved && !is_resized)
275         return;
276
277     /* Update the window position and size */
278     vout_display_cfg_t place_cfg = *cfg;
279     place_cfg.display.width  = rect.right;
280     place_cfg.display.height = rect.bottom;
281
282     vout_display_place_t place;
283     vout_display_PlacePicture(&place, source, &place_cfg, true);
284
285     EventThreadUpdateSourceAndPlace(sys->event, source, &place);
286
287     if (sys->hvideownd)
288         SetWindowPos(sys->hvideownd, 0,
289                      place.x, place.y, place.width, place.height,
290                      SWP_NOCOPYBITS|SWP_NOZORDER|SWP_ASYNCWINDOWPOS);
291
292     /* Destination image position and dimensions */
293 #if defined(MODULE_NAME_IS_direct3d)
294     rect_dest.left   = 0;
295     rect_dest.right  = place.width;
296     rect_dest.top    = 0;
297     rect_dest.bottom = place.height;
298 #else
299     rect_dest.left = point.x + place.x;
300     rect_dest.right = rect_dest.left + place.width;
301     rect_dest.top = point.y + place.y;
302     rect_dest.bottom = rect_dest.top + place.height;
303
304 #ifdef MODULE_NAME_IS_directx
305     /* Apply overlay hardware constraints */
306     if (sys->b_using_overlay) {
307         if (sys->i_align_dest_boundary)
308             rect_dest.left = (rect_dest.left +
309                               sys->i_align_dest_boundary / 2) &
310                                         ~sys->i_align_dest_boundary;
311
312         if (sys->i_align_dest_size)
313             rect_dest.right = ((rect_dest.right -
314                                 rect_dest.left +
315                                 sys->i_align_dest_size / 2) &
316                                     ~sys->i_align_dest_size) + rect_dest.left;
317     }
318 #endif
319
320 #endif
321
322 #if defined(MODULE_NAME_IS_directx) || defined(MODULE_NAME_IS_direct3d)
323     /* UpdateOverlay directdraw function doesn't automatically clip to the
324      * display size so we need to do it otherwise it will fail
325      * It is also needed for d3d to avoid exceding our surface size */
326
327     /* Clip the destination window */
328     if (!IntersectRect(&rect_dest_clipped, &rect_dest,
329                        &sys->rect_display)) {
330         SetRectEmpty(&rect_src_clipped);
331         return;
332     }
333
334 #ifndef NDEBUG
335     msg_Dbg(vd, "DirectXUpdateRects image_dst_clipped coords:"
336                 " %li,%li,%li,%li",
337                 rect_dest_clipped.left, rect_dest_clipped.top,
338                 rect_dest_clipped.right, rect_dest_clipped.bottom);
339 #endif
340
341 #else
342
343     /* AFAIK, there are no clipping constraints in Direct3D, OpenGL and GDI */
344     rect_dest_clipped = rect_dest;
345
346 #endif
347
348     /* the 2 following lines are to fix a bug when clicking on the desktop */
349     if ((rect_dest_clipped.right - rect_dest_clipped.left) == 0 ||
350         (rect_dest_clipped.bottom - rect_dest_clipped.top) == 0) {
351         SetRectEmpty(&rect_src_clipped);
352         return;
353     }
354
355     /* src image dimensions */
356     rect_src.left   = 0;
357     rect_src.top    = 0;
358     rect_src.right  = source->i_width;
359     rect_src.bottom = source->i_height;
360
361     /* Clip the source image */
362     rect_src_clipped.left = source->i_x_offset +
363       (rect_dest_clipped.left - rect_dest.left) *
364       source->i_visible_width / (rect_dest.right - rect_dest.left);
365     rect_src_clipped.right = source->i_x_offset +
366       source->i_visible_width -
367       (rect_dest.right - rect_dest_clipped.right) *
368       source->i_visible_width / (rect_dest.right - rect_dest.left);
369     rect_src_clipped.top = source->i_y_offset +
370       (rect_dest_clipped.top - rect_dest.top) *
371       source->i_visible_height / (rect_dest.bottom - rect_dest.top);
372     rect_src_clipped.bottom = source->i_y_offset +
373       source->i_visible_height -
374       (rect_dest.bottom - rect_dest_clipped.bottom) *
375       source->i_visible_height / (rect_dest.bottom - rect_dest.top);
376
377 #ifdef MODULE_NAME_IS_directx
378     /* Apply overlay hardware constraints */
379     if (sys->b_using_overlay) {
380         if (sys->i_align_src_boundary)
381             rect_src_clipped.left =
382                 (rect_src_clipped.left +
383                  sys->i_align_src_boundary / 2) &
384                             ~sys->i_align_src_boundary;
385
386         if (sys->i_align_src_size)
387             rect_src_clipped.right =
388                 ((rect_src_clipped.right - rect_src_clipped.left +
389                   sys->i_align_src_size / 2) &
390                             ~sys->i_align_src_size) + rect_src_clipped.left;
391     }
392 #elif defined(MODULE_NAME_IS_direct3d)
393     /* Needed at least with YUV content */
394     rect_src_clipped.left &= ~1;
395     rect_src_clipped.right &= ~1;
396     rect_src_clipped.top &= ~1;
397     rect_src_clipped.bottom &= ~1;
398 #endif
399
400 #ifndef NDEBUG
401     msg_Dbg(vd, "DirectXUpdateRects image_src_clipped"
402                 " coords: %li,%li,%li,%li",
403                 rect_src_clipped.left, rect_src_clipped.top,
404                 rect_src_clipped.right, rect_src_clipped.bottom);
405 #endif
406
407 #ifdef MODULE_NAME_IS_directx
408     /* The destination coordinates need to be relative to the current
409      * directdraw primary surface (display) */
410     rect_dest_clipped.left -= sys->rect_display.left;
411     rect_dest_clipped.right -= sys->rect_display.left;
412     rect_dest_clipped.top -= sys->rect_display.top;
413     rect_dest_clipped.bottom -= sys->rect_display.top;
414
415     if (sys->b_using_overlay)
416         DirectDrawUpdateOverlay(vd);
417 #endif
418
419 #ifndef UNDER_CE
420     /* Windows 7 taskbar thumbnail code */
421     LPTASKBARLIST3 taskbl;
422     OSVERSIONINFO winVer;
423     winVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
424     if (GetVersionEx(&winVer) && winVer.dwMajorVersion > 5) {
425         CoInitialize(0);
426
427         if (S_OK == CoCreateInstance(&clsid_ITaskbarList,
428                                      NULL, CLSCTX_INPROC_SERVER,
429                                      &IID_ITaskbarList3,
430                                      &taskbl)) {
431             RECT rect_video, rect_parent, rect_relative;
432             HWND hroot = GetAncestor(sys->hwnd,GA_ROOT);
433
434             taskbl->vt->HrInit(taskbl);
435             GetWindowRect(sys->hvideownd, &rect_video);
436             GetWindowRect(hroot, &rect_parent);
437             rect_relative.left = rect_video.left - rect_parent.left - 8;
438             rect_relative.right = rect_video.right - rect_video.left + rect_relative.left;
439             rect_relative.top = rect_video.top - rect_parent.top - 10;
440             rect_relative.bottom = rect_video.bottom - rect_video.top + rect_relative.top - 25;
441
442             if (S_OK != taskbl->vt->SetThumbnailClip(taskbl, hroot, &rect_relative))
443                 msg_Err(vd, "SetThumbNailClip failed");
444
445             taskbl->vt->Release(taskbl);
446         }
447         CoUninitialize();
448     }
449 #endif
450     /* Signal the change in size/position */
451     sys->changes |= DX_POSITION_CHANGE;
452
453 #undef rect_src
454 #undef rect_src_clipped
455 #undef rect_dest
456 #undef rect_dest_clipped
457 }
458
459 static int CommonControlSetFullscreen(vout_display_t *vd, bool is_fullscreen)
460 {
461     vout_display_sys_t *sys = vd->sys;
462
463 #ifdef MODULE_NAME_IS_direct3d
464     if (sys->use_desktop && is_fullscreen)
465         return VLC_EGENERIC;
466 #endif
467
468     /* */
469     if (sys->parent_window)
470         return vout_window_SetFullScreen(sys->parent_window, is_fullscreen);
471
472     /* */
473     HWND hwnd = sys->hparent && sys->hfswnd ? sys->hfswnd : sys->hwnd;
474
475     /* Save the current windows placement/placement to restore
476        when fullscreen is over */
477     WINDOWPLACEMENT window_placement;
478     window_placement.length = sizeof(WINDOWPLACEMENT);
479     GetWindowPlacement(hwnd, &window_placement);
480
481     if (is_fullscreen) {
482         msg_Dbg(vd, "entering fullscreen mode");
483
484         /* Change window style, no borders and no title bar */
485         SetWindowLong(hwnd, GWL_STYLE, WS_CLIPCHILDREN | WS_VISIBLE);
486
487         if (sys->hparent) {
488 #ifdef UNDER_CE
489             POINT point = {0,0};
490             RECT rect;
491             ClientToScreen(sys->hwnd, &point);
492             GetClientRect(sys->hwnd, &rect);
493             SetWindowPos(hwnd, 0, point.x, point.y,
494                          rect.right, rect.bottom,
495                          SWP_NOZORDER|SWP_FRAMECHANGED);
496 #else
497             /* Retrieve current window position so fullscreen will happen
498             *on the right screen */
499             HMONITOR hmon = MonitorFromWindow(sys->hparent,
500                                               MONITOR_DEFAULTTONEAREST);
501             MONITORINFO mi;
502             mi.cbSize = sizeof(MONITORINFO);
503             if (GetMonitorInfo(hmon, &mi))
504                 SetWindowPos(hwnd, 0,
505                              mi.rcMonitor.left,
506                              mi.rcMonitor.top,
507                              mi.rcMonitor.right - mi.rcMonitor.left,
508                              mi.rcMonitor.bottom - mi.rcMonitor.top,
509                              SWP_NOZORDER|SWP_FRAMECHANGED);
510 #endif
511         } else {
512             /* Maximize non embedded window */
513             ShowWindow(hwnd, SW_SHOWMAXIMIZED);
514         }
515
516         if (sys->hparent) {
517             /* Hide the previous window */
518             RECT rect;
519             GetClientRect(hwnd, &rect);
520             SetParent(sys->hwnd, hwnd);
521             SetWindowPos(sys->hwnd, 0, 0, 0,
522                          rect.right, rect.bottom,
523                          SWP_NOZORDER|SWP_FRAMECHANGED);
524
525 #ifdef UNDER_CE
526             HWND topLevelParent = GetParent(sys->hparent);
527 #else
528             HWND topLevelParent = GetAncestor(sys->hparent, GA_ROOT);
529 #endif
530             ShowWindow(topLevelParent, SW_HIDE);
531         }
532         SetForegroundWindow(hwnd);
533     } else {
534         msg_Dbg(vd, "leaving fullscreen mode");
535
536         /* Change window style, no borders and no title bar */
537         SetWindowLong(hwnd, GWL_STYLE, EventThreadGetWindowStyle(sys->event));
538
539         if (sys->hparent) {
540             RECT rect;
541             GetClientRect(sys->hparent, &rect);
542             SetParent(sys->hwnd, sys->hparent);
543             SetWindowPos(sys->hwnd, 0, 0, 0,
544                          rect.right, rect.bottom,
545                          SWP_NOZORDER|SWP_FRAMECHANGED);
546
547 #ifdef UNDER_CE
548             HWND topLevelParent = GetParent(sys->hparent);
549 #else
550             HWND topLevelParent = GetAncestor(sys->hparent, GA_ROOT);
551 #endif
552             ShowWindow(topLevelParent, SW_SHOW);
553             SetForegroundWindow(sys->hparent);
554             ShowWindow(hwnd, SW_HIDE);
555         } else {
556             /* return to normal window for non embedded vout */
557             SetWindowPlacement(hwnd, &window_placement);
558             ShowWindow(hwnd, SW_SHOWNORMAL);
559         }
560
561         /* Make sure the mouse cursor is displayed */
562         EventThreadMouseShow(sys->event);
563     }
564     return VLC_SUCCESS;
565 }
566
567 int CommonControl(vout_display_t *vd, int query, va_list args)
568 {
569     vout_display_sys_t *sys = vd->sys;
570
571     switch (query) {
572     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:   /* const vout_display_cfg_t *p_cfg, int is_forced */
573     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED: /* const vout_display_cfg_t *p_cfg */
574     case VOUT_DISPLAY_CHANGE_ZOOM:           /* const vout_display_cfg_t *p_cfg */
575     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:  /* const video_format_t *p_source */
576     case VOUT_DISPLAY_CHANGE_SOURCE_CROP: {  /* const video_format_t *p_source */
577         const vout_display_cfg_t *cfg;
578         const video_format_t *source;
579         bool  is_forced = true;
580         if (query == VOUT_DISPLAY_CHANGE_SOURCE_CROP ||
581             query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT) {
582             cfg    = vd->cfg;
583             source = va_arg(args, const video_format_t *);
584         } else {
585             cfg    = va_arg(args, const vout_display_cfg_t *);
586             source = &vd->source;
587             if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE)
588                 is_forced = va_arg(args, int);
589         }
590         if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE && is_forced) {
591             /* Update dimensions */
592             if (sys->parent_window) {
593                 vout_window_SetSize(sys->parent_window, cfg->display.width, cfg->display.height);
594             } else {
595                 RECT rect_window;
596                 rect_window.top    = 0;
597                 rect_window.left   = 0;
598                 rect_window.right  = cfg->display.width;
599                 rect_window.bottom = cfg->display.height;
600                 AdjustWindowRect(&rect_window, EventThreadGetWindowStyle(sys->event), 0);
601
602                 SetWindowPos(sys->hwnd, 0, 0, 0,
603                              rect_window.right - rect_window.left,
604                              rect_window.bottom - rect_window.top, SWP_NOMOVE);
605             }
606         }
607         UpdateRects(vd, cfg, source, is_forced);
608         return VLC_SUCCESS;
609     }
610     case VOUT_DISPLAY_CHANGE_WINDOW_STATE: {       /* unsigned state */
611         const unsigned state = va_arg(args, unsigned);
612         const bool is_on_top = (state & VOUT_WINDOW_STATE_ABOVE) != 0;
613 #ifdef MODULE_NAME_IS_direct3d
614         if (sys->use_desktop && is_on_top)
615             return VLC_EGENERIC;
616 #endif
617         if (sys->parent_window) {
618             if (vout_window_SetState(sys->parent_window, state))
619                 return VLC_EGENERIC;
620         } else {
621             HMENU hMenu = GetSystemMenu(sys->hwnd, FALSE);
622
623             if (is_on_top && !(GetWindowLong(sys->hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)) {
624                 CheckMenuItem(hMenu, IDM_TOGGLE_ON_TOP, MF_BYCOMMAND | MFS_CHECKED);
625                 SetWindowPos(sys->hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
626             } else if (!is_on_top && (GetWindowLong(sys->hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)) {
627                 CheckMenuItem(hMenu, IDM_TOGGLE_ON_TOP, MF_BYCOMMAND | MFS_UNCHECKED);
628                 SetWindowPos(sys->hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
629             }
630         }
631         sys->is_on_top = is_on_top;
632         return VLC_SUCCESS;
633     }
634     case VOUT_DISPLAY_CHANGE_FULLSCREEN: {   /* const vout_display_cfg_t *p_cfg */
635         const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
636         return CommonControlSetFullscreen(vd, cfg->is_fullscreen);
637     }
638
639     case VOUT_DISPLAY_RESET_PICTURES:
640     case VOUT_DISPLAY_HIDE_MOUSE:
641         assert(0);
642     default:
643         return VLC_EGENERIC;
644     }
645 }
646
647 #ifndef UNDER_CE
648 static void DisableScreensaver(vout_display_t *vd)
649 {
650     vout_display_sys_t *sys = vd->sys;
651
652     /* disable screensaver by temporarily changing system settings */
653     sys->i_spi_lowpowertimeout = 0;
654     sys->i_spi_powerofftimeout = 0;
655     sys->i_spi_screensavetimeout = 0;
656     if (var_GetBool(vd, "disable-screensaver")) {
657         msg_Dbg(vd, "disabling screen saver");
658         SystemParametersInfo(SPI_GETLOWPOWERTIMEOUT, 0,
659                              &sys->i_spi_lowpowertimeout, 0);
660         if (0 != sys->i_spi_lowpowertimeout) {
661             SystemParametersInfo(SPI_SETLOWPOWERTIMEOUT, 0, NULL, 0);
662         }
663         SystemParametersInfo(SPI_GETPOWEROFFTIMEOUT, 0,
664                              &sys->i_spi_powerofftimeout, 0);
665         if (0 != sys->i_spi_powerofftimeout) {
666             SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT, 0, NULL, 0);
667         }
668         SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT, 0,
669                              &sys->i_spi_screensavetimeout, 0);
670         if (0 != sys->i_spi_screensavetimeout) {
671             SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT, 0, NULL, 0);
672         }
673     }
674 }
675
676 static void RestoreScreensaver(vout_display_t *vd)
677 {
678     vout_display_sys_t *sys = vd->sys;
679
680     /* restore screensaver system settings */
681     if (0 != sys->i_spi_lowpowertimeout) {
682         SystemParametersInfo(SPI_SETLOWPOWERTIMEOUT,
683                              sys->i_spi_lowpowertimeout, NULL, 0);
684     }
685     if (0 != sys->i_spi_powerofftimeout) {
686         SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT,
687                              sys->i_spi_powerofftimeout, NULL, 0);
688     }
689     if (0 != sys->i_spi_screensavetimeout) {
690         SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT,
691                              sys->i_spi_screensavetimeout, NULL, 0);
692     }
693 }
694 #endif
695