Undocks window first before side-snapping bounds

ash/wm/workspace/workspace_layout_manager.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 "ash/wm/workspace/workspace_layout_manager.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/base_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/views/corewm/window_util.h"
 
 using aura::Window;
 
 namespace ash {
 
 namespace internal {
 
 namespace {
 
 // This specifies how much percent 30% of a window rect (width / height)
 // must be visible when the window is added to the workspace.
 const float kMinimumPercentOnScreenArea = 0.3f;
 
+// Duration of slide animation used when a snapped window is adjusted.
+const int kSlideDurationMs = 120;
+
 void MoveToDisplayForRestore(wm::WindowState* window_state) {
   if (!window_state->HasRestoreBounds())
     return;
   const gfx::Rect& restore_bounds = window_state->GetRestoreBoundsInScreen();
 
   // Move only if the restore bounds is outside of
   // the display. There is no information about in which
   // display it should be restored, so this is best guess.
   // TODO(oshima): Restore information should contain the
   // work area information like WindowResizer does for the
@@ skipping 62 matching lines @@
           false, child->GetRootWindow());
     }
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
   }
   UpdateDesktopVisibility();
 }
 
 void WorkspaceLayoutManager::SetChildBounds(
     Window* child,
     const gfx::Rect& requested_bounds) {
-  if (!wm::GetWindowState(child)->tracked_by_workspace()) {
+  wm::WindowState* window_state = wm::GetWindowState(child);
+  if (!window_state->tracked_by_workspace()) {
     SetChildBoundsDirect(child, requested_bounds);
     return;
   }
   gfx::Rect child_bounds(requested_bounds);
   // Some windows rely on this to set their initial bounds.
-  if (!SetMaximizedOrFullscreenBounds(wm::GetWindowState(child))) {
+  if (!SetMaximizedOrFullscreenBounds(window_state)) {
     // Non-maximized/full-screen windows have their size constrained to the
     // work-area.
     child_bounds.set_width(std::min(work_area_in_parent_.width(),
                                     child_bounds.width()));
     child_bounds.set_height(
         std::min(work_area_in_parent_.height(), child_bounds.height()));
-    SetChildBoundsDirect(child, child_bounds);
+    AdjustSnappedBounds(window_state, &child_bounds);
+    if (window_state->IsSnapped())
+      SetChildBoundsAnimated(child, child_bounds);
+    else
+      SetChildBoundsDirect(child, child_bounds);
   }
   UpdateDesktopVisibility();
 }
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   const gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
       window_->parent()));
   if (work_area != work_area_in_parent_) {
     AdjustAllWindowsBoundsForWorkAreaChange(
         ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED);
@@ skipping 98 matching lines @@
     case ADJUST_WINDOW_DISPLAY_SIZE_CHANGED:
       // The work area may be smaller than the full screen.  Put as much of the
       // window as possible within the display area.
       bounds.AdjustToFit(work_area_in_parent_);
       break;
     case ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED:
       ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(
           work_area_in_parent_, &bounds);
       break;
   }
+  AdjustSnappedBounds(window_state, &bounds);
   if (window_state->window()->bounds() != bounds)
-    window_state->window()->SetBounds(bounds);
+    SetChildBoundsAnimated(window_state->window(), bounds);
 }
 
 void WorkspaceLayoutManager::AdjustWindowBoundsWhenAdded(
     wm::WindowState* window_state) {
   // Don't adjust window bounds if the bounds are empty as this
   // happens when a new views::Widget is created.
   // When a window is dragged and dropped onto a different
   // root window, the bounds will be updated after they are added
   // to the root window.
   if (window_state->window()->bounds().IsEmpty())
@@ skipping 10 matching lines @@
   int min_width = bounds.width() * kMinimumPercentOnScreenArea;
   int min_height = bounds.height() * kMinimumPercentOnScreenArea;
   // Use entire display instead of workarea because the workarea can
   // be further shrunk by the docked area. The logic ensures 30%
   // visibility which should be enough to see where the window gets
   // moved.
   gfx::Rect display_area = ScreenAsh::GetDisplayBoundsInParent(window);
 
   ash::wm::AdjustBoundsToEnsureWindowVisibility(
       display_area, min_width, min_height, &bounds);
+  AdjustSnappedBounds(window_state, &bounds);
   if (window->bounds() != bounds)
     window->SetBounds(bounds);
 }
 
 void WorkspaceLayoutManager::UpdateDesktopVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
 void WorkspaceLayoutManager::UpdateBoundsFromShowState(
     wm::WindowState* window_state,
     ui::WindowShowState last_show_state) {
   aura::Window* window = window_state->window();
   // See comment in SetMaximizedOrFullscreenBounds() as to why we use parent in
   // these calculation.
+  // TODO(varkha): Change the switch statement below to use wm::WindowShowType.
   switch (window_state->GetShowState()) {
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_NORMAL: {
       // Make sure that the part of the window is always visible
       // when restored.
       gfx::Rect bounds_in_parent;
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(
             work_area_in_parent_, &bounds_in_parent);
       } else {
         // Minimized windows have no restore bounds.
         // Use the current bounds instead.
         bounds_in_parent = window->bounds();
         ash::wm::AdjustBoundsToEnsureMinimumWindowVisibility(
             work_area_in_parent_, &bounds_in_parent);
         // Don't start animation if the bounds didn't change.
         if (bounds_in_parent == window->bounds())
           bounds_in_parent.SetRect(0, 0, 0, 0);
       }
+      AdjustSnappedBounds(window_state, &bounds_in_parent);
       if (!bounds_in_parent.IsEmpty()) {
         gfx::Rect new_bounds = BaseLayoutManager::BoundsWithScreenEdgeVisible(
             window->parent()->parent(),
             bounds_in_parent);
-        if (last_show_state == ui::SHOW_STATE_MINIMIZED)
+        if ((last_show_state == ui::SHOW_STATE_DEFAULT ||
+             last_show_state == ui::SHOW_STATE_NORMAL) &&
+            window_state->IsSnapped()) {
+          SetChildBoundsAnimated(window, new_bounds);
+        } else if (last_show_state == ui::SHOW_STATE_MINIMIZED) {
           SetChildBoundsDirect(window, new_bounds);
-        else
+        } else {
           CrossFadeToBounds(window, new_bounds);
+        }
       }
       window_state->ClearRestoreBounds();
       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED: {
       MoveToDisplayForRestore(window_state);
       gfx::Rect new_bounds = ScreenAsh::GetMaximizedWindowBoundsInParent(
           window->parent()->parent());
       // If the window is restored from minimized state, do not make the cross
@@ skipping 41 matching lines @@
   if (window_state->IsFullscreen()) {
     SetChildBoundsDirect(
         window_state->window(),
         ScreenAsh::GetDisplayBoundsInParent(
             window_state->window()->parent()->parent()));
     return true;
   }
   return false;
 }
 
+void WorkspaceLayoutManager::AdjustSnappedBounds(wm::WindowState* window_state,
+                                                 gfx::Rect* bounds) {
+  if (!window_state->tracked_by_workspace() ||
+      !window_state->IsNormalShowState() ||
+      !window_state->IsSnapped()) {
+    return;
+  }
+  gfx::Rect maximized_bounds = ScreenAsh::GetMaximizedWindowBoundsInParent(
+      window_state->window()->parent()->parent());
+  if (window_state->window_show_type() == wm::SHOW_TYPE_LEFT_SNAPPED)
+    bounds->set_x(maximized_bounds.x());
+  else if (window_state->window_show_type() == wm::SHOW_TYPE_RIGHT_SNAPPED)
+    bounds->set_x(maximized_bounds.right() - bounds->width());
+  bounds->set_y(maximized_bounds.y());
+  // TODO(varkha): Set width to 50% here for snapped windows.
+  bounds->set_height(maximized_bounds.height());
+}
+
+void WorkspaceLayoutManager::SetChildBoundsAnimated(Window* child,
+                                                    const gfx::Rect& bounds) {
+  ui::Layer* layer = child->layer();
+  ui::ScopedLayerAnimationSettings slide_settings(layer->GetAnimator());
+  slide_settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  slide_settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kSlideDurationMs));
+  SetChildBoundsDirect(child, bounds);
+}
+
 }  // namespace internal
 }  // namespace ash