Remove app/win/win_util.h,cc etc.

views/window/window_win.cc

 // Copyright (c) 2011 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/win/win_util.h"
 #include "base/i18n/rtl.h"
+#include "base/win/scoped_gdi_object.h"
+#include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "gfx/canvas_skia_paint.h"
 #include "gfx/font.h"
 #include "gfx/icon_util.h"
 #include "gfx/path.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
+#include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/win/hwnd_util.h"
 #include "views/accessibility/view_accessibility.h"
 #include "views/widget/root_view.h"
 #include "views/window/client_view.h"
 #include "views/window/custom_frame_view.h"
 #include "views/window/native_frame_view.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window_delegate.h"
 
 namespace {
 
 static const int kDragFrameWindowAlpha = 200;
 
+// The thickness of an auto-hide taskbar in pixels.
+static const int kAutoHideTaskbarThicknessPx = 2;
+
 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;
@@ skipping 39 matching lines @@
       MONITORINFO mi = {0};
       mi.cbSize = sizeof(mi);
       GetMonitorInfo(monitor, &mi);
       parent_rect = mi.rcWork;
     } else {
       NOTREACHED() << "Unable to get default monitor";
     }
   }
 
   gfx::Rect actual_bounds = bounds;
-  app::win::EnsureRectIsVisibleInRect(gfx::Rect(parent_rect), &actual_bounds,
-                                      padding);
+  views::internal::EnsureRectIsVisibleInRect(gfx::Rect(parent_rect),
+                                             &actual_bounds, padding);
 
   SetWindowPos(child_window, insert_after_window, actual_bounds.x(),
                actual_bounds.y(), actual_bounds.width(),
                actual_bounds.height(), flags);
 }
 
+// Returns true if edge |edge| (one of ABE_LEFT, TOP, RIGHT, or BOTTOM) of
+// monitor |monitor| has an auto-hiding taskbar that's always-on-top.
+bool EdgeHasTopmostAutoHideTaskbar(UINT edge, HMONITOR monitor) {
+  APPBARDATA taskbar_data = { 0 };
+  taskbar_data.cbSize = sizeof APPBARDATA;
+  taskbar_data.uEdge = edge;
+  HWND taskbar = reinterpret_cast<HWND>(SHAppBarMessage(ABM_GETAUTOHIDEBAR,
+                                                        &taskbar_data));
+  return ::IsWindow(taskbar) && (monitor != NULL) &&
+      (MonitorFromWindow(taskbar, MONITOR_DEFAULTTONULL) == monitor) &&
+      (GetWindowLong(taskbar, GWL_EXSTYLE) & WS_EX_TOPMOST);
+}
+
 }  // namespace
 
 namespace views {
 
+namespace internal {
+
+void EnsureRectIsVisibleInRect(const gfx::Rect& parent_rect,
+                               gfx::Rect* child_rect,
+                               int padding) {
+  DCHECK(child_rect);
+
+  // We use padding here because it allows some of the original web page to
+  // bleed through around the edges.
+  int twice_padding = padding * 2;
+
+  // FIRST, clamp width and height so we don't open child windows larger than
+  // the containing parent.
+  if (child_rect->width() > (parent_rect.width() + twice_padding))
+    child_rect->set_width(std::max(0, parent_rect.width() - twice_padding));
+  if (child_rect->height() > parent_rect.height() + twice_padding)
+    child_rect->set_height(std::max(0, parent_rect.height() - twice_padding));
+
+  // SECOND, clamp x,y position to padding,padding so we don't position child
+  // windows in hyperspace.
+  // TODO(mpcomplete): I don't see what the second check in each 'if' does that
+  // isn't handled by the LAST set of 'ifs'.  Maybe we can remove it.
+  if (child_rect->x() < parent_rect.x() ||
+      child_rect->x() > parent_rect.right()) {
+    child_rect->set_x(parent_rect.x() + padding);
+  }
+  if (child_rect->y() < parent_rect.y() ||
+      child_rect->y() > parent_rect.bottom()) {
+    child_rect->set_y(parent_rect.y() + padding);
+  }
+
+  // LAST, nudge the window back up into the client area if its x,y position is
+  // within the parent bounds but its width/height place it off-screen.
+  if (child_rect->bottom() > parent_rect.bottom())
+    child_rect->set_y(parent_rect.bottom() - child_rect->height() - padding);
+  if (child_rect->right() > parent_rect.right())
+    child_rect->set_x(parent_rect.right() - child_rect->width() - padding);
+}
+
+}  // namespace internal
+
 // 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
 // rendering is being done *inside* the default implementation of some message
 // handlers and functions:
@@ skipping 122 matching lines @@
     SendMessage(GetNativeView(), WM_SYSCOMMAND, command, 0);
 }
 
 namespace {
 static BOOL CALLBACK SendDwmCompositionChanged(HWND window, LPARAM param) {
   SendMessage(window, WM_DWMCOMPOSITIONCHANGED, 0, 0);
   return TRUE;
 }
 }  // namespace
 
-void WindowWin::FrameTypeChanged() {
-  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
-    // We need to toggle the rendering policy of the DWM/glass frame as we
-    // change from opaque to glass. "Non client rendering enabled" means that
-    // the DWM's glass non-client rendering is enabled, which is why
-    // DWMNCRP_ENABLED is used for the native frame case. _DISABLED means the
-    // DWM doesn't render glass, and so is used in the custom frame case.
-    DWMNCRENDERINGPOLICY policy =
-        non_client_view_->UseNativeFrame() ? DWMNCRP_ENABLED
-                                           : DWMNCRP_DISABLED;
-    DwmSetWindowAttribute(GetNativeView(), DWMWA_NCRENDERING_POLICY,
-                          &policy, sizeof(DWMNCRENDERINGPOLICY));
-  }
-
-  // Send a frame change notification, since the non-client metrics have
-  // changed.
-  SetWindowPos(NULL, 0, 0, 0, 0,
-               SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
-                   SWP_NOOWNERZORDER | SWP_NOACTIVATE);
-
-  // The frame type change results in the client rect changing size, but this
-  // does not explicitly send a WM_SIZE, so we need to force the root view to
-  // be resized now.
-  LayoutRootView();
-
-  // Update the non-client view with the correct frame view for the active frame
-  // type.
-  non_client_view_->UpdateFrame();
-
-  // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
-  // to notify our children too, since we can have MDI child windows who need to
-  // update their appearance.
-  EnumChildWindows(GetNativeView(), &SendDwmCompositionChanged, NULL);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WindowWin, Window implementation:
 
 void WindowWin::Show() {
   int show_state = GetShowState();
   if (saved_maximized_state_)
     show_state = SW_SHOWMAXIMIZED;
   Show(show_state);
 }
 
@@ skipping 247 matching lines @@
   return GetNativeView();
 }
 
 bool WindowWin::ShouldUseNativeFrame() const {
   ui::ThemeProvider* tp = GetThemeProvider();
   if (!tp)
     return WidgetWin::IsAeroGlassEnabled();
   return tp->ShouldUseNativeFrame();
 }
 
+void WindowWin::FrameTypeChanged() {
+  // Called when the frame type could possibly be changing (theme change or
+  // DWM composition change).
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    // We need to toggle the rendering policy of the DWM/glass frame as we
+    // change from opaque to glass. "Non client rendering enabled" means that
+    // the DWM's glass non-client rendering is enabled, which is why
+    // DWMNCRP_ENABLED is used for the native frame case. _DISABLED means the
+    // DWM doesn't render glass, and so is used in the custom frame case.
+    DWMNCRENDERINGPOLICY policy =
+        non_client_view_->UseNativeFrame() ? DWMNCRP_ENABLED
+                                           : DWMNCRP_DISABLED;
+    DwmSetWindowAttribute(GetNativeView(), DWMWA_NCRENDERING_POLICY,
+                          &policy, sizeof(DWMNCRENDERINGPOLICY));
+  }
+
+  // Send a frame change notification, since the non-client metrics have
+  // changed.
+  SetWindowPos(NULL, 0, 0, 0, 0,
+               SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
+                   SWP_NOOWNERZORDER | SWP_NOACTIVATE);
+
+  // The frame type change results in the client rect changing size, but this
+  // does not explicitly send a WM_SIZE, so we need to force the root view to
+  // be resized now.
+  LayoutRootView();
+
+  // Update the non-client view with the correct frame view for the active frame
+  // type.
+  non_client_view_->UpdateFrame();
+
+  // WM_DWMCOMPOSITIONCHANGED is only sent to top level windows, however we want
+  // to notify our children too, since we can have MDI child windows who need to
+  // update their appearance.
+  EnumChildWindows(GetNativeView(), &SendDwmCompositionChanged, NULL);
+}
+
+
+// static
+gfx::Font WindowWin::GetWindowTitleFont() {
+  NONCLIENTMETRICS ncm;
+  base::win::GetNonClientMetrics(&ncm);
+  l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
+  base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
+  return gfx::Font(caption_font);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // WindowWin, protected:
 
 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),
@@ skipping 279 matching lines @@
       // the window rect given with WM_NCCALCSIZE (which is our previous
       // restored window position) we will get the correct monitor handle.
       monitor = MonitorFromRect(client_rect, MONITOR_DEFAULTTONULL);
       if (!monitor) {
         // This is probably an extreme case that we won't hit, but if we don't
         // intersect any monitor, let us not adjust the client rect since our
         // window will not be visible anyway.
         return 0;
       }
     }
-    if (app::win::EdgeHasTopmostAutoHideTaskbar(ABE_LEFT, monitor))
-      client_rect->left += app::win::kAutoHideTaskbarThicknessPx;
-    if (app::win::EdgeHasTopmostAutoHideTaskbar(ABE_TOP, monitor)) {
+    if (EdgeHasTopmostAutoHideTaskbar(ABE_LEFT, monitor))
+      client_rect->left += kAutoHideTaskbarThicknessPx;
+    if (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 += app::win::kAutoHideTaskbarThicknessPx;
+        client_rect->top += kAutoHideTaskbarThicknessPx;
       }
     }
-    if (app::win::EdgeHasTopmostAutoHideTaskbar(ABE_RIGHT, monitor))
-      client_rect->right -= app::win::kAutoHideTaskbarThicknessPx;
-    if (app::win::EdgeHasTopmostAutoHideTaskbar(ABE_BOTTOM, monitor))
-      client_rect->bottom -= app::win::kAutoHideTaskbarThicknessPx;
+    if (EdgeHasTopmostAutoHideTaskbar(ABE_RIGHT, monitor))
+      client_rect->right -= kAutoHideTaskbarThicknessPx;
+    if (EdgeHasTopmostAutoHideTaskbar(ABE_BOTTOM, monitor))
+      client_rect->bottom -= 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
@@ skipping 697 matching lines @@
   Window::CloseSecondaryWidget(root_view->GetWidget());
   return TRUE;
 }
 }  // namespace
 
 void Window::CloseAllSecondaryWindows() {
   EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
 }
 
 }  // namespace views