Make sure the RootView is sized to the correct bounds when the opaque frame i...

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 "views/window/window_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "app/gfx/canvas_paint.h"
@@ skipping 510 matching lines @@
                      &last_work_area_);
   ResetWindowRegion(false);
 }
 
 void WindowWin::SizeWindowToDefault() {
   win_util::CenterAndSizeWindow(owning_window(), GetNativeView(),
                                 non_client_view_->GetPreferredSize().ToSIZE(),
                                 false);
 }
 
+gfx::Insets WindowWin::GetClientAreaInsets() const {
+  // Returning an empty Insets object causes the default handling in
+  // WidgetWin::OnNCCalcSize() to be invoked.
+  if (GetNonClientView()->UseNativeFrame())
+    return gfx::Insets();
+
+  if (IsMaximized()) {
+    // Windows automatically adds a standard width border to all sides when a
+    // window is maximized.
+    int border_thickness = GetSystemMetrics(SM_CXSIZEFRAME);
+    return gfx::Insets(border_thickness, border_thickness, border_thickness,
+                       border_thickness);
+  }
+  // This is weird, but highly essential. If we don't offset the bottom edge
+  // of the client rect, the window client area and window area will match,
+  // and when returning to glass rendering mode from non-glass, the client
+  // area will not paint black as transparent. This is because (and I don't
+  // know why) the client area goes from matching the window rect to being
+  // something else. If the client area is not the window rect in both
+  // modes, the blackness doesn't occur. Because of this, we need to tell
+  // the RootView to lay out to fit the window rect, rather than the client
+  // rect when using the opaque frame. See GetRootViewSize.
+  // Note: this is only required for non-fullscreen windows. Note that
+  // fullscreen windows are in restored state, not maximized.
+  return gfx::Insets(0, 0, !IsFullscreen() ? 1 : 0, 0);

[Peter Kasting, 2009/10/23 05:09:31]

Nit: Could remove the ! and reverse the condition

+}
+
 void WindowWin::RunSystemMenu(const gfx::Point& point) {
   // We need to reset and clean up any currently created system menu objects.
   // We need to call this otherwise there's a small chance that we aren't going
   // to get a system menu. We also can't take the return value of this
   // function. We need to call it *again* to get a valid HMENU.
   //::GetSystemMenu(GetNativeView(), TRUE);
   UINT flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD;
   if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
     flags |= TPM_RIGHTALIGN;
   HMENU system_menu = ::GetSystemMenu(GetNativeView(), FALSE);
@@ skipping 154 matching lines @@
 
   // Reset the disable inactive rendering state since activation has changed.
   if (disable_inactive_rendering_) {
     disable_inactive_rendering_ = false;
     return CallDefaultNCActivateHandler(TRUE);
   }
   return CallDefaultNCActivateHandler(active);
 }
 
 LRESULT WindowWin::OnNCCalcSize(BOOL mode, LPARAM l_param) {
-  // We only need to adjust the client size/paint handling when we're not using
-  // the native frame.
-  if (non_client_view_->UseNativeFrame())
+  // We only override WM_NCCALCSIZE if we want non-standard non-client edge
+  // width.
+  gfx::Insets insets = GetClientAreaInsets();
+  if (insets.width() == 0 && insets.height() == 0)

[Peter Kasting, 2009/10/23 05:09:31]

Nit: I'm not in a position to check, but is there an Insets::empty() function? 
Should there be?

     return WidgetWin::OnNCCalcSize(mode, l_param);
 
   RECT* client_rect = mode ?
       &reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param)->rgrc[0] :
       reinterpret_cast<RECT*>(l_param);
+  client_rect->left += insets.left();
+  client_rect->top += insets.top();
+  client_rect->bottom -= insets.bottom();
+  client_rect->right -= insets.right();
   if (IsMaximized()) {
-    // 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_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_TOP, monitor)) {
+      if (GetNonClientView()->UseNativeFrame()) {
+        // Tricky bit.  Due to a bug in DwmDefWindowProc()'s handling of
+        // WM_NCHITTEST, having any nonclient area atop the window causes the
+        // caption buttons to draw onscreen but not respond to mouse
+        // hover/clicks.
+        // So for a taskbar at the screen top, we can't push the
+        // client_rect->top down; instead, we move the bottom up by one pixel,
+        // which is the smallest change we can make and still get a client area
+        // less than the screen size. This is visibly ugly, but there seems to
+        // be no better solution.
+        --client_rect->bottom;
+      } else {
+        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
     // exhibits bugs where client pixels and child HWNDs are mispositioned by
     // the width/height of the upper-left nonclient area.
     return 0;
   }
 
   // If the window bounds change, we're going to relayout and repaint anyway.
   // Returning WVR_REDRAW avoids an extra paint before that of the old client
   // pixels in the (now wrong) location, and thus makes actions like resizing a
   // window from the left edge look slightly less broken.
+  // We special case when left and top insets are 0, since these conditions

[Peter Kasting, 2009/10/23 05:09:31]

Nit: and -> or

+  // actually require another repaint to correct the layout after glass gets
+  // turned on and off.
+  if (insets.left() == 0 || insets.top() == 0)
+    return 0;
   return mode ? WVR_REDRAW : 0;
 }
 
 LRESULT WindowWin::OnNCHitTest(const CPoint& point) {
   // First, give the NonClientView a chance to test the point to see if it
   // provides any of the non-client area.
   CPoint temp = point;
   MapWindowPoints(HWND_DESKTOP, GetNativeView(), &temp, 1);
   int component = non_client_view_->NonClientHitTest(gfx::Point(temp));
   if (component != HTNOWHERE)
@@ skipping 364 matching lines @@
       }
       last_monitor_ = monitor;
       last_monitor_rect_ = monitor_rect;
       last_work_area_ = work_area;
     }
   }
 
   WidgetWin::OnWindowPosChanging(window_pos);
 }
 
+gfx::Size WindowWin::GetRootViewSize() const {
+  // The native frame and maximized modes need to supply the client rect as
+  // determined by the relevant WM_NCCALCSIZE handling, so we just use the
+  // default handling which does this.
+  if (GetNonClientView()->UseNativeFrame() || IsMaximized())
+    return WidgetWin::GetRootViewSize();
+
+  // When using an opaque frame, we consider the entire window rect to be client
+  // area visually.
+  CRect rect;
+  GetWindowRect(&rect);
+  return gfx::Size(rect.Width(), rect.Height());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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.
   DCHECK(owning_hwnd_) << "Can't create a modal dialog without an owner";
   HWND start = owning_hwnd_;
   while (start != NULL) {
@@ skipping 237 matching lines @@
   Window::CloseSecondaryWidget(root_view->GetWidget());
   return TRUE;
 }
 }  // namespace
 
 void Window::CloseAllSecondaryWindows() {
   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
 }
 
 }  // namespace views