git.sesse.net Git - vlc/blob - 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