Reorganize fullscreen mode handling. Now nearly everything is in WindowWin. ...

chrome/views/window/window_win.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/views/window/window_win.h"
 
 #include <shellapi.h>
 
 #include "base/win_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/gfx/chrome_font.h"
 #include "chrome/common/gfx/icon_util.h"
 #include "chrome/common/gfx/path.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/common/win_util.h"
 #include "chrome/views/widget/root_view.h"
 #include "chrome/views/window/client_view.h"
 #include "chrome/views/window/custom_frame_view.h"
 #include "chrome/views/window/native_frame_view.h"
 #include "chrome/views/window/non_client_view.h"
 #include "chrome/views/window/window_delegate.h"
 #include "grit/generated_resources.h"
 
+namespace {
+
+bool GetMonitorAndRects(const RECT& rect,
+                        HMONITOR* monitor,
+                        gfx::Rect* monitor_rect,
+                        gfx::Rect* work_area) {
+  DCHECK(monitor);
+  DCHECK(monitor_rect);
+  DCHECK(work_area);
+  *monitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONULL);
+  if (!*monitor)
+    return false;
+  MONITORINFO monitor_info = { 0 };
+  monitor_info.cbSize = sizeof(monitor_info);
+  GetMonitorInfo(*monitor, &monitor_info);
+  *monitor_rect = monitor_info.rcMonitor;
+  *work_area = monitor_info.rcWork;
+  return true;
+}
+
+}  // namespace
+
 namespace views {
 
 // A scoping class that prevents a window from being able to redraw in response
 // to invalidations that may occur within it for the lifetime of the object.
 //
 // Why would we want such a thing? Well, it turns out Windows has some
 // "unorthodox" behavior when it comes to painting its non-client areas.
 // Occasionally, Windows will paint portions of the default non-client area
 // right over the top of the custom frame. This is not simply fixed by handling
 // WM_NCPAINT/WM_PAINT, with some investigation it turns out that this
@@ skipping 51 matching lines @@
   window->Init(parent, bounds);
   return window;
 }
 
 gfx::Rect WindowWin::GetBounds() const {
   gfx::Rect bounds;
   WidgetWin::GetBounds(&bounds, true);
   return bounds;
 }
 
+gfx::Rect WindowWin::GetNormalBounds() const {
+  // If we're in fullscreen mode, we've changed the normal bounds to the monitor
+  // rect, so return the saved bounds instead.
+  if (IsFullscreen())
+    return gfx::Rect(saved_window_info_.window_rect);
+
+  WINDOWPLACEMENT wp;
+  wp.length = sizeof(wp);
+  const bool ret = !!GetWindowPlacement(GetNativeView(), &wp);
+  DCHECK(ret);
+  return gfx::Rect(wp.rcNormalPosition);
+}
+
 void WindowWin::SetBounds(const gfx::Rect& bounds) {
   SetBounds(bounds, NULL);
 }
 
 void WindowWin::SetBounds(const gfx::Rect& bounds,
                           gfx::NativeWindow other_window) {
   win_util::SetChildBounds(GetNativeView(), GetParent(), other_window, bounds,
                            kMonitorEdgePadding, 0);
 }
 
@@ skipping 22 matching lines @@
 
 int WindowWin::GetShowState() const {
   return SW_SHOWNORMAL;
 }
 
 void WindowWin::ExecuteSystemMenuCommand(int command) {
   if (command)
     SendMessage(GetNativeView(), WM_SYSCOMMAND, command, 0);
 }
 
+void WindowWin::PushForceHidden() {
+  if (force_hidden_count_++ == 0)
+    Hide();
+}
+
+void WindowWin::PopForceHidden() {
+  if (--force_hidden_count_ <= 0) {
+    force_hidden_count_ = 0;
+    ShowWindow(SW_SHOW);
+  }
+}
+
 // static
 int Window::GetLocalizedContentsWidth(int col_resource_id) {
   double chars = _wtof(l10n_util::GetString(col_resource_id).c_str());
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   ChromeFont font = rb.GetFont(ResourceBundle::BaseFont);
   int width = font.GetExpectedTextWidth(static_cast<int>(chars));
   DCHECK(width > 0);
   return width;
 }
 
@@ skipping 77 matching lines @@
 }
 
 bool WindowWin::IsMaximized() const {
   return !!::IsZoomed(GetNativeView());
 }
 
 bool WindowWin::IsMinimized() const {
   return !!::IsIconic(GetNativeView());
 }
 
+void WindowWin::SetFullscreen(bool fullscreen) {
+  if (fullscreen_ == fullscreen)
+    return;  // Nothing to do.
+
+  // Toggle fullscreen mode.
+  fullscreen_ = fullscreen;
+
+  // Reduce jankiness during the following position changes by hiding the window
+  // until it's in the final position.
+  PushForceHidden();
+
+  // Size/position/style window appropriately.
+  HWND hwnd = GetNativeView();
+  if (fullscreen_) {
+    // Save current window information.  We force the window into restored mode
+    // before going fullscreen because Windows doesn't seem to hide the
+    // taskbar if the window is in the maximized state.
+    saved_window_info_.maximized = IsMaximized();
+    if (saved_window_info_.maximized)
+      ExecuteSystemMenuCommand(SC_RESTORE);
+    saved_window_info_.style = GetWindowLong(GWL_STYLE);
+    saved_window_info_.ex_style = GetWindowLong(GWL_EXSTYLE);
+    GetWindowRect(&saved_window_info_.window_rect);
+
+    // Set new window style and size.
+    MONITORINFO monitor_info;
+    monitor_info.cbSize = sizeof(monitor_info);
+    GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST),
+                   &monitor_info);
+    gfx::Rect monitor_rect(monitor_info.rcMonitor);
+    SetWindowLong(GWL_STYLE,
+                  saved_window_info_.style & ~(WS_CAPTION | WS_THICKFRAME));
+    SetWindowLong(GWL_EXSTYLE,
+                  saved_window_info_.ex_style & ~(WS_EX_DLGMODALFRAME |
+                  WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
+    SetWindowPos(NULL, monitor_rect.x(), monitor_rect.y(),
+                 monitor_rect.width(), monitor_rect.height(),
+                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+  } else {
+    // Reset original window style and size.  The multiple window size/moves
+    // here are ugly, but if SetWindowPos() doesn't redraw, the taskbar won't be
+    // repainted.  Better-looking methods welcome.
+    gfx::Rect new_rect(saved_window_info_.window_rect);
+    SetWindowLong(GWL_STYLE, saved_window_info_.style);
+    SetWindowLong(GWL_EXSTYLE, saved_window_info_.ex_style);
+    SetWindowPos(NULL, new_rect.x(), new_rect.y(), new_rect.width(),
+                 new_rect.height(),
+                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+    if (saved_window_info_.maximized)
+      ExecuteSystemMenuCommand(SC_MAXIMIZE);
+  }
+
+  // Undo our anti-jankiness hacks.
+  PopForceHidden();
+}
+
+bool WindowWin::IsFullscreen() const {
+  return fullscreen_;
+}
+
 void WindowWin::EnableClose(bool enable) {
   // If the native frame is rendering its own close button, ask it to disable.
   non_client_view_->EnableClose(enable);
 
   // Disable the native frame's close button regardless of whether or not the
   // native frame is in use, since this also affects the system menu.
   EnableMenuItem(GetSystemMenu(GetNativeView(), false),
                  SC_CLOSE, enable ? MF_ENABLED : MF_GRAYED);
 
   // Let the window know the frame changed.
@@ skipping 93 matching lines @@
 WindowWin::WindowWin(WindowDelegate* window_delegate)
     : WidgetWin(),
       focus_on_creation_(true),
       window_delegate_(window_delegate),
       non_client_view_(new NonClientView(this)),
       owning_hwnd_(NULL),
       minimum_size_(100, 100),
       is_modal_(false),
       restored_enabled_(false),
       is_always_on_top_(false),
+      fullscreen_(false),
       window_closed_(false),
       disable_inactive_rendering_(false),
       is_active_(false),
       lock_updates_(false),
       saved_window_style_(0),
       saved_maximized_state_(0),
-      force_hidden_(false) {
+      ignore_window_pos_changes_(false),
+      ignore_pos_changes_factory_(this),
+      force_hidden_count_(0),
+      last_monitor_(NULL) {
   InitClass();
   DCHECK(window_delegate_);
   window_delegate_->window_.reset(this);
   // Initialize these values to 0 so that subclasses can override the default
   // behavior before calling Init.
   set_window_style(0);
   set_window_ex_style(0);
 }
 
 void WindowWin::Init(HWND parent, const gfx::Rect& bounds) {
@@ skipping 18 matching lines @@
   // Create the ClientView, add it to the NonClientView and add the
   // NonClientView to the RootView. This will cause everything to be parented.
   non_client_view_->set_client_view(window_delegate_->CreateClientView(this));
   WidgetWin::SetContentsView(non_client_view_);
 
   UpdateWindowTitle();
 
   SetInitialBounds(bounds);
   InitAlwaysOnTopState();
 
+  GetMonitorAndRects(bounds.ToRECT(), &last_monitor_, &last_monitor_rect_,
+                     &last_work_area_);
+
   if (!IsAppWindow()) {
     notification_registrar_.Add(
         this,
         NotificationType::ALL_APPWINDOWS_CLOSED,
         NotificationService::AllSources());
   }
 
   ResetWindowRegion(false);
 
   NotificationService::current()->Notify(
@@ skipping 84 matching lines @@
   // (now), saving off its placement so it can be properly restored once
   // everything has settled down.
   WINDOWPLACEMENT saved_window_placement;
   saved_window_placement.length = sizeof(WINDOWPLACEMENT);
   GetWindowPlacement(GetNativeView(), &saved_window_placement);
   Hide();
 
   // Important step: restore the window first, since our hiding hack doesn't
   // work for maximized windows! We tell the frame not to allow itself to be
   // made visible though, which removes the brief flicker.
-  force_hidden_ = true;
+  ++force_hidden_count_;
   ::ShowWindow(GetNativeView(), SW_RESTORE);
-  force_hidden_ = false;
+  --force_hidden_count_;
 
   // We respond to this in response to WM_DWMCOMPOSITIONCHANGED since that is
   // the only thing we care about - we don't actually respond to WM_THEMECHANGED
   // messages.
   non_client_view_->SetUseNativeFrame(win_util::ShouldUseVistaFrame());
 
   // Now that we've updated the frame, we'll want to restore our saved placement
   // since the display should have settled down and we can be properly rendered.
   SetWindowPlacement(GetNativeView(), &saved_window_placement);
 
@@ skipping 111 matching lines @@
     // Make the maximized mode client rect fit the screen exactly, by
     // subtracting the border Windows automatically adds for maximized mode.
     int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
     InflateRect(client_rect, -border_thickness, -border_thickness);
 
     // Find all auto-hide taskbars along the screen edges and adjust in by the
     // thickness of the auto-hide taskbar on each such edge, so the window isn't
     // treated as a "fullscreen app", which would cause the taskbars to
     // disappear.
     HMONITOR monitor = MonitorFromWindow(GetNativeView(),
-                                         MONITOR_DEFAULTTONEAREST);
+                                         MONITOR_DEFAULTTONULL);
     if (win_util::EdgeHasTopmostAutoHideTaskbar(ABE_LEFT, monitor))
       client_rect->left += win_util::kAutoHideTaskbarThicknessPx;
     if (win_util::EdgeHasTopmostAutoHideTaskbar(ABE_TOP, monitor))
       client_rect->top += win_util::kAutoHideTaskbarThicknessPx;
     if (win_util::EdgeHasTopmostAutoHideTaskbar(ABE_RIGHT, monitor))
       client_rect->right -= win_util::kAutoHideTaskbarThicknessPx;
     if (win_util::EdgeHasTopmostAutoHideTaskbar(ABE_BOTTOM, monitor))
       client_rect->bottom -= win_util::kAutoHideTaskbarThicknessPx;
 
     // We cannot return WVR_REDRAW when there is nonclient area, or Windows
@@ skipping 253 matching lines @@
                        reinterpret_cast<LPARAM>(new_icon));
 }
 
 LRESULT WindowWin::OnSetText(const wchar_t* text) {
   // This shouldn't hurt even if we're using the native frame.
   ScopedRedrawLock lock(this);
   return DefWindowProc(GetNativeView(), WM_SETTEXT, NULL,
                        reinterpret_cast<LPARAM>(text));
 }
 
+void WindowWin::OnSettingChange(UINT flags, const wchar_t* section) {
+  if (!GetParent() && (flags == SPI_SETWORKAREA)) {
+    // Fire a dummy SetWindowPos() call, so we'll trip the code in
+    // OnWindowPosChanging() below that notices work area changes.
+    ::SetWindowPos(GetNativeView(), 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
+        SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
+    SetMsgHandled(TRUE);
+  } else {
+    WidgetWin::OnSettingChange(flags, section);
+  }
+}
+
 void WindowWin::OnSize(UINT size_param, const CSize& new_size) {
   // Don't no-op if the new_size matches current size. If our normal bounds
   // and maximized bounds are the same, then we need to layout (because we
   // layout differently when maximized).
   SaveWindowPosition();
   ChangeSize(size_param, new_size);
   RedrawWindow(GetNativeView(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
 
   // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
   // invoked OnSize we ensure the RootView has been laid out.
@@ skipping 46 matching lines @@
     // Run the system menu at the NonClientView's desired location.
     RunSystemMenu(non_client_view_->GetSystemMenuPoint());
   } else {
     // Use the default implementation for any other command.
     DefWindowProc(GetNativeView(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(click.y, click.x));
   }
 }
 
 void WindowWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
-  if (force_hidden_) {
+  if (force_hidden_count_) {
     // Prevent the window from being made visible if we've been asked to do so.
     // See comment in header as to why we might want this.
     window_pos->flags &= ~SWP_SHOWWINDOW;
   }
+
+  if (ignore_window_pos_changes_) {
+    // If somebody's trying to toggle our visibility, change the nonclient area,
+    // change our Z-order, or activate us, we should probably let it go through.
+    if (!(window_pos->flags & ((IsVisible() ? SWP_HIDEWINDOW : SWP_SHOWWINDOW) |
+        SWP_FRAMECHANGED)) &&
+        (window_pos->flags & (SWP_NOZORDER | SWP_NOACTIVATE))) {
+      // Just sizing/moving the window; ignore.
+      window_pos->flags |= SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW;
+      window_pos->flags &= ~(SWP_SHOWWINDOW | SWP_HIDEWINDOW);
+    }
+  } else if (!GetParent()) {
+    CRect window_rect;
+    HMONITOR monitor;
+    gfx::Rect monitor_rect, work_area;
+    if (GetWindowRect(&window_rect) &&
+        GetMonitorAndRects(window_rect, &monitor, &monitor_rect, &work_area)) {
+      if (monitor && (monitor == last_monitor_) &&
+          (IsFullscreen() || ((monitor_rect == last_monitor_rect_) &&
+                              (work_area != last_work_area_)))) {
+        // A rect for the monitor we're on changed.  Normally Windows notifies
+        // us about this (and thus we're reaching here due to the SetWindowPos()
+        // call in OnSettingChange() above), but with some software (e.g.
+        // nVidia's nView desktop manager) the work area can change asynchronous
+        // to any notification, and we're just sent a SetWindowPos() call with a
+        // new (frequently incorrect) position/size.  In either case, the best
+        // response is to throw away the existing position/size information in
+        // |window_pos| and recalculate it based on the old window coordinates,
+        // adjusted for the change in the work area (or, for fullscreen windows,
+        // to just set it to the monitor rect).
+        if (IsFullscreen()) {
+          window_pos->x = monitor_rect.x();
+          window_pos->y = monitor_rect.y();
+          window_pos->cx = monitor_rect.width();
+          window_pos->cy = monitor_rect.height();
+        } else if (IsZoomed()) {
+          window_pos->x =
+              window_rect.left + work_area.x() - last_work_area_.x();
+          window_pos->y = window_rect.top + work_area.y() - last_work_area_.y();
+          window_pos->cx = window_rect.Width() + work_area.width() -
+              last_work_area_.width();
+          window_pos->cy = window_rect.Height() + work_area.height() -
+              last_work_area_.height();
+        } else {
+          gfx::Rect window_gfx_rect(window_rect);
+          gfx::Rect new_window_rect = window_gfx_rect.AdjustToFit(work_area);
+          window_pos->x = new_window_rect.x();
+          window_pos->y = new_window_rect.y();
+          window_pos->cx = new_window_rect.width();
+          window_pos->cy = new_window_rect.height();
+        }
+        // WARNING!  Don't set SWP_FRAMECHANGED here, it breaks moving the child
+        // HWNDs for some reason.
+        window_pos->flags &= ~(SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW);
+        window_pos->flags |= SWP_NOCOPYBITS;
+
+        // Now ignore all immediately-following SetWindowPos() changes.  Windows
+        // likes to (incorrectly) recalculate what our position/size should be
+        // and send us further updates.
+        ignore_window_pos_changes_ = true;
+        DCHECK(ignore_pos_changes_factory_.empty());
+        MessageLoop::current()->PostTask(FROM_HERE,
+            ignore_pos_changes_factory_.NewRunnableMethod(
+            &WindowWin::StopIgnoringPosChanges));
+      }
+      last_monitor_ = monitor;
+      last_monitor_rect_ = monitor_rect;
+      last_work_area_ = work_area;
+    }
+  }
+
   WidgetWin::OnWindowPosChanging(window_pos);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowWin, private:
 
 void WindowWin::BecomeModal() {
   // We implement modality by crawling up the hierarchy of windows starting
   // at the owner, disabling all of them so that they don't receive input
   // messages.
@@ skipping 171 matching lines @@
   DCHECK(r);
 
   bool maximized = (win_placement.showCmd == SW_SHOWMAXIMIZED);
   CRect window_bounds(win_placement.rcNormalPosition);
   window_delegate_->SaveWindowPlacement(
       gfx::Rect(win_placement.rcNormalPosition), maximized, is_always_on_top_);
 }
 
 void WindowWin::LockUpdates() {
   lock_updates_ = true;
-  saved_window_style_ = GetWindowLong(GetNativeView(), GWL_STYLE);
-  SetWindowLong(GetNativeView(), GWL_STYLE, saved_window_style_ & ~WS_VISIBLE);
+  saved_window_style_ = GetWindowLong(GWL_STYLE);
+  SetWindowLong(GWL_STYLE, saved_window_style_ & ~WS_VISIBLE);
 }
 
 void WindowWin::UnlockUpdates() {
-  SetWindowLong(GetNativeView(), GWL_STYLE, saved_window_style_);
+  SetWindowLong(GWL_STYLE, saved_window_style_);
   lock_updates_ = false;
 }
 
 void WindowWin::ResetWindowRegion(bool force) {
   // A native frame uses the native window region, and we don't want to mess
   // with it.
   if (non_client_view_->UseNativeFrame()) {
     if (force)
       SetWindowRgn(NULL, TRUE);
     return;
@@ skipping 48 matching lines @@
     resize_cursors_[RC_NORMAL] = LoadCursor(NULL, IDC_ARROW);
     resize_cursors_[RC_VERTICAL] = LoadCursor(NULL, IDC_SIZENS);
     resize_cursors_[RC_HORIZONTAL] = LoadCursor(NULL, IDC_SIZEWE);
     resize_cursors_[RC_NESW] = LoadCursor(NULL, IDC_SIZENESW);
     resize_cursors_[RC_NWSE] = LoadCursor(NULL, IDC_SIZENWSE);
     initialized = true;
   }
 }
 
 }  // namespace views