Improving window auto management between workspaces

ash/wm/workspace/auto_window_management.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/auto_window_management.h"
+
+#include "ash/ash_switches.h"
+#include "ash/shell.h"
+#include "ash/wm/window_animations.h"
+#include "ash/wm/window_util.h"
+#include "base/command_line.h"
+#include "ui/aura/window.h"
+#include "ui/aura/client/aura_constants.h"
+#include "ui/compositor/layer_animator.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/screen.h"
+
+namespace ash {
+namespace internal {
+
+namespace {
+
+// The time in milliseconds which should be used to visually move a window
+// through an automatic "intelligent" window management option.
+const int kWindowAutoMoveDurationMS = 125;
+
+// Check if the given |window| is marked to get managed.
+bool WindowIsManaged(const aura::Window* window) {
+  return (!window->bounds().IsEmpty() && wm::IsWindowPositionManaged(window));
+}
+
+// Check if a given |window| can be managed. This includes that it's state is
+// not minimized/maximized/the user has changed it's size by hand already.
+// It furthermore checks for the WindowIsManaged status.
+bool WindowPositionCanBeManaged(const aura::Window* window) {
+  return (WindowIsManaged(window) &&
+          !wm::IsWindowMinimized(window) &&
+          !wm::IsWindowMaximized(window) &&
+          !wm::HasUserChangedWindowPositionOrSize(window));
+}
+
+// Given a |window|, return the |work_area| of the desktop on which it is
+// located as well as the only |other_window| which has an impact on the
+// automated window location management. If there is more then one windows,
+// false is returned, but the |other_window| will be set to the first one
+// found.
+// If the return value is true a single window was found.
+// Note: |work_area| is undefined if false is returned and |other_window| is
+// NULL.
+bool GetOtherVisibleAndManageableWindow(const aura::Window* window,
+                                        gfx::Rect* work_area,
+                                        aura::Window** other_window) {
+  *other_window = NULL;
+  // If the given window was not manageable, it cannot have caused a management
+  // operation earlier.
+  if (!WindowIsManaged(window))
+    return false;
+
+  // Get our work area.
+  *work_area = gfx::Rect(window->parent()->bounds().size());
+  work_area->Inset(Shell::GetScreen()->GetDisplayMatching(
+      *work_area).GetWorkAreaInsets());
+
+  const aura::Window::Windows& windows = window->parent()->children();
+  // Find a single open managed window.
+  for (size_t i = 0; i < windows.size(); i++) {
+    aura::Window* iterated_window = windows[i];
+    if (window != iterated_window &&
+        iterated_window->type() == aura::client::WINDOW_TYPE_NORMAL &&
+        iterated_window->TargetVisibility() &&
+        WindowIsManaged(iterated_window)) {
+      // Bail if we find a second usable window.
+      if (*other_window)
+        return false;
+      *other_window = iterated_window;
+    }
+  }
+  return *other_window != NULL;
+}
+
+// Move the given |bounds| on the available |parent_width| to the
+// direction. If |move_right| is true, the rectangle gets moved to the right
+// corner, otherwise to the left one.
+bool MoveRectToOneSide(int parent_width, bool move_right, gfx::Rect* bounds) {
+  if (move_right) {
+    if (parent_width > bounds->right()) {
+      bounds->set_x(parent_width - bounds->width());
+      return true;
+    }
+  } else {
+    if (0 < bounds->x()) {
+      bounds->set_x(0);
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace
+
+void RearrangeVisibleWindowOnHide(const aura::Window* removed_window) {
+  // Find a single open browser window.
+  aura::Window* shown_window = NULL;
+  gfx::Rect work_area;
+  if (!GetOtherVisibleAndManageableWindow(removed_window,
+                                          &work_area,
+                                          &shown_window))
+      return;
+
+  if (WindowPositionCanBeManaged(shown_window)) {
+    // Center the window (only in x).
+    gfx::Rect bounds = shown_window->bounds();
+    bounds.set_x((work_area.width() - bounds.width()) / 2);
+    if (bounds != shown_window->bounds()) {
+      if (!shown_window->GetProperty(aura::client::kAnimationsDisabledKey) &&
+          !CommandLine::ForCurrentProcess()->HasSwitch(
+               ash::switches::kAshWindowAnimationsDisabled)) {
+        ui::LayerAnimator* animator = shown_window->layer()->GetAnimator();
+        ui::ScopedLayerAnimationSettings animation_setter(animator);
+        animation_setter.SetTransitionDuration(
+            base::TimeDelta::FromMilliseconds(kWindowAutoMoveDurationMS));
+      }
+      shown_window->SetBounds(bounds);
+    }
+  }
+}
+
+void RearrangeVisibleWindowOnShow(aura::Window* added_window) {
+  // Find a single open managed window.

[sky, 2012/10/17 15:59:38]

This code would be a lot easier to reason about if you added an early out if
!added_window->TargetVisibility(). And yes, I get that that eventually happens
now.

[Mr4D (OOO till 08-26), 2012/10/17 18:43:56]

Done.

+  aura::Window* shown_window = NULL;
+  gfx::Rect work_area;
+  if (!GetOtherVisibleAndManageableWindow(added_window,
+                                          &work_area,
+                                          &shown_window)) {

[sky, 2012/10/17 15:59:38]

shown_window is particularly confusing name to use here since this method is is
named with Show yet show_window is not the paramater. Maybe other_window as that
corresponds with GetOtherVisibleAndManageableWindow? Use the same name in
RearrangeVisibleWindowOnHide similarly above.

[Mr4D (OOO till 08-26), 2012/10/17 18:43:56]

Done.

+    // It could be that this window is the first window joining the workspace.
+    if (!WindowPositionCanBeManaged(added_window) || shown_window)
+      return;
+    // If so we have to make sure it is centered.
+    gfx::Rect bounds = added_window->bounds();
+    bounds.set_x((work_area.width() - bounds.width()) / 2);
+    added_window->SetBounds(bounds);
+    return;
+  }
+
+  if (WindowPositionCanBeManaged(shown_window)) {
+    // Push away the other window.
+    gfx::Rect other_bounds = shown_window->bounds();
+    bool move_right = other_bounds.CenterPoint().x() < work_area.width() / 2;
+    if (MoveRectToOneSide(work_area.width(), move_right, &other_bounds)) {
+      if (other_bounds != shown_window->bounds()) {
+        if (!shown_window->GetProperty(aura::client::kAnimationsDisabledKey) &&
+            !CommandLine::ForCurrentProcess()->HasSwitch(
+                 ash::switches::kAshWindowAnimationsDisabled)) {
+          ui::LayerAnimator* animator = shown_window->layer()->GetAnimator();

[sky, 2012/10/17 15:59:38]

This is why nothing is animating. As soon as ScopedLayerAnimatorSettings drops
out of scope the transition duration goes back to the default and SetBounds is
effectively immediate. You need to move shown_window->SetBounds() into this
block.

[Mr4D (OOO till 08-26), 2012/10/17 18:43:56]

Aha! So that was the problem... Well - as stated earlier: I don't really like
how the animation system works. Having the same function doing two different
things in the same closure seems bad. Done - and thanks for finding that!

+          ui::ScopedLayerAnimationSettings animation_setter(animator);
+          animation_setter.SetTransitionDuration(
+              base::TimeDelta::FromMilliseconds(kWindowAutoMoveDurationMS));
+        }
+        shown_window->SetBounds(other_bounds);
+      }
+    }
+    // Push the new window also to the opposite location (if needed).
+    // Since it is just coming into view, we do not need to animate it.
+    gfx::Rect added_bounds = added_window->bounds();
+    if (MoveRectToOneSide(work_area.width(), !move_right, &added_bounds))
+      added_window->SetBounds(added_bounds);
+  }
+}
+
+} // namespace internal
+} // namespace ash
+