Preliminary metro snap plumbing.

ui/views/widget/native_widget_win.cc

 // Copyright (c) 2012 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 "ui/views/widget/native_widget_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include <algorithm>
@@ skipping 404 matching lines @@
       use_layered_buffer_(false),
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       can_update_layered_window_(true),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
       previous_cursor_(NULL),
       fullscreen_(false),
+      metro_snap_(false),
       force_hidden_count_(0),
       lock_updates_count_(0),
       ignore_window_pos_changes_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ignore_pos_changes_factory_(this)),
       last_monitor_(NULL),
       is_right_mouse_pressed_on_caption_(false),
       restored_enabled_(false),
       destroyed_(NULL),
       has_non_client_view_(false) {
 }
@@ skipping 548 matching lines @@
 bool NativeWidgetWin::IsMinimized() const {
   return !!::IsIconic(GetNativeView());
 }
 
 void NativeWidgetWin::Restore() {
   ExecuteSystemMenuCommand(SC_RESTORE);
 }
 
 void NativeWidgetWin::SetFullscreen(bool fullscreen) {
   if (fullscreen_ == fullscreen)
-    return;  // Nothing to do.
+    return;
+
+  gfx::Rect window_rect;
+  if (fullscreen) {
+    MONITORINFO monitor_info;
+    monitor_info.cbSize = sizeof(monitor_info);
+    GetMonitorInfo(MonitorFromWindow(GetNativeView(), MONITOR_DEFAULTTONEAREST),
+      &monitor_info);
+    window_rect = monitor_info.rcMonitor;
+  }
+
+  SetFullscreenInternal(fullscreen, window_rect);
+}
+
+void NativeWidgetWin::SetMetroSnapFullscreen(bool metro_snap) {
+  if (metro_snap_ == metro_snap)
+    return;
+
+  metro_snap_ = metro_snap;
+
+  gfx::Rect window_rect;
+  if (!metro_snap) {
+    MONITORINFO monitor_info;
+    monitor_info.cbSize = sizeof(monitor_info);
+    GetMonitorInfo(MonitorFromWindow(GetNativeView(), MONITOR_DEFAULTTONEAREST),
+                &monitor_info);
+    window_rect = monitor_info.rcMonitor;
+  }
+
+  SetFullscreenInternal(metro_snap, window_rect);
+}
+
+void NativeWidgetWin::SetFullscreenInternal(bool fullscreen,
+                                            const gfx::Rect& window_rect) {
 
   // Reduce jankiness during the following position changes by hiding the window
   // until it's in the final position.
   PushForceHidden();
 
   // Size/position/style window appropriately.
   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)
       Restore();
     saved_window_info_.style = GetWindowLong(GWL_STYLE);
     saved_window_info_.ex_style = GetWindowLong(GWL_EXSTYLE);
     GetWindowRect(&saved_window_info_.window_rect);
   }
 
   fullscreen_ = fullscreen;
 
   if (fullscreen_) {
     // Set new window style and size.
-    MONITORINFO monitor_info;
-    monitor_info.cbSize = sizeof(monitor_info);
-    GetMonitorInfo(MonitorFromWindow(GetNativeView(), 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);
+
+    // On expand, if we're given a window_rect, grow to it, otherwise do
+    // not resize.
+    if (window_rect.width() > 0) {
+      SetWindowPos(NULL, window_rect.x(), window_rect.y(),
+                   window_rect.width(), window_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);
+
+    // On restore, if we're given a window_rect resize to that, otherwise
+    // resize to the previous saved rect size.
+    gfx::Rect new_rect;
+    if (window_rect.width() > 0) {
+      new_rect = window_rect;
+    } else {
+      new_rect = saved_window_info_.window_rect;
+    }
+
     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)
       Maximize();
   }
 
   // Undo our anti-jankiness hacks.
   PopForceHidden();
 }
 
 bool NativeWidgetWin::IsFullscreen() const {
   return fullscreen_;
 }
 
+bool NativeWidgetWin::IsInMetroSnapMode() const {
+  return metro_snap_;
+}
+
 void NativeWidgetWin::SetOpacity(unsigned char opacity) {
   layered_alpha_ = static_cast<BYTE>(opacity);
   GetWidget()->GetRootView()->SchedulePaint();
 }
 
 void NativeWidgetWin::SetUseDragFrame(bool use_drag_frame) {
   if (use_drag_frame) {
     // Make the frame slightly transparent during the drag operation.
     drag_frame_saved_window_style_ = GetWindowLong(GWL_STYLE);
     drag_frame_saved_window_ex_style_ = GetWindowLong(GWL_EXSTYLE);
@@ skipping 1039 matching lines @@
       // 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)) {
+      bool work_area_changed = (monitor_rect == last_monitor_rect_) &&
+                               (work_area != last_work_area_);
       if (monitor && (monitor == last_monitor_) &&
-          (IsFullscreen() || ((monitor_rect == last_monitor_rect_) &&
-              (work_area != last_work_area_)))) {
+          ((IsFullscreen() && !metro_snap_) || work_area_changed)) {
         // 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 new work rect.
         gfx::Rect new_window_rect;
         if (IsFullscreen()) {
@@ skipping 609 matching lines @@
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   // This currently isn't necessary because we're not generating touch events on
   // windows.  When we do, this will need to be updated.
   return false;
 }
 
 }  // namespace internal
 
 }  // namespace views