Fix various problems with work area change notifications so that we now (hope...

chrome/views/widget/widget_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/widget/widget_win.h"
 
 #include "base/gfx/native_theme.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/win_util.h"
 #include "chrome/views/accessibility/view_accessibility.h"
 #include "chrome/views/controls/native_control_win.h"
 #include "chrome/views/fill_layout.h"
 #include "chrome/views/focus/focus_util_win.h"
 #include "chrome/views/widget/aero_tooltip_manager.h"
 #include "chrome/views/widget/hwnd_notification_source.h"
 #include "chrome/views/widget/root_view.h"
 
+namespace {
+
+bool GetMonitorAndWorkAreaForRect(const RECT& rect,
+                                  HMONITOR* monitor,
+                                  gfx::Rect* work_area) {
+  DCHECK(monitor);
+  DCHECK(work_area);
+  *monitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST);
+  if (!*monitor)
+    return false;
+  MONITORINFO monitor_info = { 0 };
+  monitor_info.cbSize = sizeof(monitor_info);
+  GetMonitorInfo(*monitor, &monitor_info);
+  *work_area = monitor_info.rcWork;
+  return true;
+}
+
+}  // namespace
+
 namespace views {
 
 static const DWORD kWindowDefaultChildStyle =
     WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
 static const DWORD kWindowDefaultStyle = WS_OVERLAPPEDWINDOW;
 static const DWORD kWindowDefaultExStyle = 0;
 
 // Property used to link the HWND to its RootView.
 static const wchar_t* const kRootViewWindowProperty = L"__ROOT_VIEW__";
 
@@ skipping 62 matching lines @@
 typedef std::list<RegisteredClass> RegisteredClasses;
 
 // The list of registered classes.
 static RegisteredClasses* registered_classes = NULL;
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
-    : active_mouse_tracking_flags_(0),
+    : close_widget_factory_(this),
+      ignore_pos_changes_factory_(this),
+      active_mouse_tracking_flags_(0),
       has_capture_(false),
       current_action_(FA_NONE),
       toplevel_(false),
       window_style_(0),
       window_ex_style_(kWindowDefaultExStyle),
       use_layered_buffer_(true),
       layered_alpha_(255),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       last_mouse_event_was_move_(false),
       is_mouse_down_(false),
       class_style_(CS_DBLCLKS),
       hwnd_(NULL),
-      close_widget_factory_(this) {
+      last_monitor_(NULL),
+      ignore_window_pos_changes_(false) {
 }
 
 WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 void WidgetWin::Init(HWND parent, const gfx::Rect& bounds,
                      bool has_own_focus_manager) {
   toplevel_ = parent == NULL;
 
@@ skipping 15 matching lines @@
     parent = NULL;
   }
 
   hwnd_ = CreateWindowEx(window_ex_style_, GetWindowClassName().c_str(), L"",
                          window_style_, bounds.x(), bounds.y(), bounds.width(),
                          bounds.height(), parent, NULL, NULL, this);
   DCHECK(hwnd_);
   TRACK_HWND_CREATION(hwnd_);
   SetWindowSupportsRerouteMouseWheel(hwnd_);
 
+  GetMonitorAndWorkAreaForRect(bounds.ToRECT(), &last_monitor_,
+                               &last_work_area_);
+
   // The window procedure should have set the data for us.
   DCHECK(win_util::GetWindowUserData(hwnd_) == this);
 
   root_view_->OnWidgetCreated();
 
   if (has_own_focus_manager) {
     FocusManager::CreateFocusManager(hwnd_, GetRootView());
   } else {
     // Subclass the window so we get the tab key messages when a view with no
     // associated native window is focused.
@@ skipping 495 matching lines @@
 void WidgetWin::OnRButtonUp(UINT flags, const CPoint& point) {
   ProcessMouseReleased(point, flags | MK_RBUTTON);
 }
 
 void WidgetWin::OnRButtonDblClk(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_RBUTTON, true, false);
 }
 
 void WidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
   if (toplevel_ && (flags == SPI_SETWORKAREA)) {
-    AdjustWindowToFitScreenSize();
+    // 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);
   }
 }
 
 void WidgetWin::OnSize(UINT param, const CSize& size) {
   ChangeSize(param, size);
 }
 
 void WidgetWin::OnThemeChanged() {
   // Notify NativeTheme.
   gfx::NativeTheme::instance()->CloseHandles();
 }
 
+void WidgetWin::OnWindowPosChanging(WINDOWPOS* window_pos) {
+  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 (toplevel_) {

[Ben Goodger (Google), 2009/04/10 19:59:03]

Can you just use !GetParent() here instead? I want to remove toplevel_. Maybe
you could add a note by the toplevel_ decl too. I think its flaky to have a
variable that incompletely maps to a property that's easily accessible from a
API call.

If you like using something called toplevel, feel free to add a method called
IsToplevel that just returns !GetParent().

[Peter Kasting, 2009/04/10 20:05:02]

Yep, and I can just remove toplevel_ entirely, going one better than merely
commenting it :)

+    CRect window_rect;
+    HMONITOR monitor;
+    gfx::Rect work_area;
+    if (GetWindowRect(&window_rect) &&
+        GetMonitorAndWorkAreaForRect(window_rect, &monitor, &work_area)) {
+      if ((monitor == last_monitor_) && (work_area != last_work_area_)) {
+        // The work area 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.
+        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(
+            &WidgetWin::StopIgnoringPosChanges));
+      }
+      last_monitor_ = monitor;
+      last_work_area_ = work_area;
+    }
+  }
+
+  SetMsgHandled(FALSE);
+}
+
 void WidgetWin::OnFinalMessage(HWND window) {
   if (delete_on_destroy_)
     delete this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, protected:
 
 void WidgetWin::TrackMouseEvents(DWORD mouse_tracking_flags) {
   // Begin tracking mouse events for this HWND so that we get WM_MOUSELEAVE
@@ skipping 102 matching lines @@
 }
 
 void WidgetWin::ProcessMouseExited() {
   last_mouse_event_was_move_ = false;
   root_view_->ProcessOnMouseExited();
   // Reset our tracking flag so that future mouse movement over this WidgetWin
   // results in a new tracking session.
   active_mouse_tracking_flags_ = 0;
 }
 
-void WidgetWin::AdjustWindowToFitScreenSize() {
-  // Desktop size has changed. Make sure we're still on screen.
-  CRect wr;
-  GetWindowRect(&wr);
-  HMONITOR hmon = MonitorFromRect(&wr, MONITOR_DEFAULTTONEAREST);
-  if (!hmon) {
-    // No monitor available.
-    return;
-  }
-
-  MONITORINFO mi;
-  mi.cbSize = sizeof(mi);
-  GetMonitorInfo(hmon, &mi);
-  gfx::Rect window_rect(wr);
-  gfx::Rect monitor_rect(mi.rcWork);
-  gfx::Rect new_window_rect = window_rect.AdjustToFit(monitor_rect);
-  if (!new_window_rect.Equals(window_rect)) {
-    // New position differs from last, resize window.
-    ::SetWindowPos(GetNativeView(),
-                   0,
-                   new_window_rect.x(),
-                   new_window_rect.y(),
-                   new_window_rect.width(),
-                   new_window_rect.height(),
-                   SWP_NOACTIVATE | SWP_NOZORDER);
-  }
-}
-
 void WidgetWin::ChangeSize(UINT size_param, const CSize& size) {
   CRect rect;
   if (use_layered_buffer_) {
     GetWindowRect(&rect);
     SizeContents(rect);
   } else {
     GetClientRect(&rect);
   }
 
   // Resizing changes the size of the view hierarchy and thus forces a
@@ skipping 157 matching lines @@
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     TRACK_HWND_DESTRUCTION(window);
     widget->hwnd_ = NULL;
     widget->OnFinalMessage(window);
   }
   return result;
 }
 
 }  // namespace views