Make the workspace cycler animation parameters editable via chrome://gesture

ash/wm/workspace/workspace_cycler_animator.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_cycler_animator.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/workspace/colored_window_controller.h"
 #include "ash/wm/workspace/workspace.h"
+#include "ash/wm/workspace/workspace_cycler_configuration.h"
+#include "base/values.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/widget/widget.h"
 
-namespace {
-
-// The maximum number of visible workspaces deeper than the selected workspace.
-const int kMinVisibleOffsetFromSelected = -2;
-
-// The maximum number of visible workspaces shallower than the selected
-// workspace.
-const int kMaxVisibleOffsetFromSelected = 3;
-
-// The scale of the selected workspace when it is completely selected.
-const double kSelectedWorkspaceScale = 0.95;
-
-// The minimum scale for workspaces in the top stack. The scales of the
-// workspaces in the top stack decrease as you go deeper into the stack.
-const double kMinTopStackScale = 0.9;
-
-// The maximum scale for workspaces in the bottom stack. The scales of the
-// workspaces in the bottom stack increase as you go up the stack.
-const double kMaxBottomStackScale = 1.0;
-
-// The minimum workspace brightness.
-const float kMinBrightness = -0.4f;
-
-// The required vertical scroll amount to cycle to the next / previous
-// workspace.
-const double kScrollAmountToCycleToNextWorkspace = 10;
-
-// The ratio of the duration of the animation to the amount that the user has
-// scrolled.
-// The duration of an animation is computed by:
-//   distance scrolled * |kCyclerStepAnimationDurationRatio|.
-const double kCyclerStepAnimationDurationRatio = 10;
-
-// The duration of the animations when animating starting the cycler.
-const int kStartCyclerAnimationDuration = 100;
-
-// The duration of the animations when animating stopping the cycler.
-const int kStopCyclerAnimationDuration = 100;
-
-// The background opacity.
-const float kBackgroundOpacity = .8f;
-
-}  // namespace
+typedef ash::WorkspaceCyclerConfiguration Config;
 
 namespace ash {
 namespace internal {
 
 // Class which computes the transform, brightness, and visbility of workspaces
 // on behalf of the animator.
 class StyleCalculator {
  public:
   StyleCalculator(const gfx::Rect& screen_bounds,
                   const gfx::Rect& maximized_bounds,
@@ skipping 45 matching lines @@
   // |offset_from_selected| from the selected workspace.
   // This method assumes |scroll_delta| == 0.
   float GetTargetBrightnessForOffset(int offset_from_selected) const;
 
   // Returns the target animation visibility of the workspace with the given
   // parameters.
   // This method assumes |scroll_delta| == 0.
   bool GetTargetVisibilityForOffset(int offset_from_selected,
                                     size_t workspace_index) const;
 
+  // Returns the minimum offset from the selected workspace at which a
+  // workspace can be visible. The offset is used to limit the amount of
+  // workspaces which are simultaneously visible.
+  int GetMinVisibleOffsetFromSelected() const;
+
+  // Returns the maximum offset from the selected workspace at which a
+  // workspace can be visible. The offset is used to limit the amount of
+  // workspaces which are simultaneously visible.
+  int GetMaxVisibleOffsetFromSelected() const;
+
   // The bounds of the display containing the workspaces in workspace
   // coordinates, including the shelf if any.
   const gfx::Rect screen_bounds_;
 
   // The bounds of a maximized window. This excludes the shelf if any.
   const gfx::Rect maximized_bounds_;
 
   // The combined number of visible and hidden workspaces.
   size_t num_workspaces_;
 
@@ skipping 51 matching lines @@
   if (scroll_delta < 0) {
     // The user is part of the way to selecting the workspace at
     // |selected_workspace_index| - 1 -> |offset_from_selected| + 1.
     second_offset_from_selected = offset_from_selected + 1;
   } else if (scroll_delta > 0) {
     // The user is part of the way to selecting the workspace at
     // |selected_workspace_index| + 1 -> |offset_from_selected| - 1.
     second_offset_from_selected = offset_from_selected - 1;
   }
 
-  double progress = fabs(scroll_delta / kScrollAmountToCycleToNextWorkspace);
+  double scroll_distance_to_cycle_to_next_workspace = Config::GetDouble(
+      Config::SCROLL_DISTANCE_TO_CYCLE_TO_NEXT_WORKSPACE);
+  double progress = fabs(
+      scroll_delta / scroll_distance_to_cycle_to_next_workspace);
   DCHECK_GT(1.0, progress);
 
   if (transform) {
     gfx::DecomposedTransform first_transform = GetTargetTransformForOffset(
         first_offset_from_selected);
 
     gfx::DecomposedTransform interpolated_transform;
     if (first_offset_from_selected == second_offset_from_selected) {
       interpolated_transform = first_transform;
     } else {
@@ skipping 29 matching lines @@
     int offset_from_selected) const {
   if (offset_from_selected <= 0) {
     // The selected workspace takes up the entire screen. The workspaces deeper
     // than the selected workspace are stacked exactly under the selected
     // workspace and are completely occluded by it.
     return gfx::Transform();
   }
 
   // The workspaces shallower than the selected workspace are stacked exactly
   // on top of each other offscreen.
+  double max_scale = Config::GetDouble(Config::MAX_SCALE);
+
   gfx::Transform transform;
   transform.Translate(0, screen_bounds_.height());
-  transform.Scale(kMaxBottomStackScale, kMaxBottomStackScale);
+  transform.Scale(max_scale, max_scale);
   return transform;
 }
 
 gfx::DecomposedTransform StyleCalculator::GetTargetTransformForOffset(
     int offset_from_selected) const {
   // When cycling, the workspaces are spread out from the positions computed by
   // GetStoppedTargetTransformForOffset(). The transforms are computed so that
   // on screen the workspaces look like this:
   //  ____________________________________________
   // |          ________________________          |
   // |         |    deepest workpace    |_________|_
   // |        _|________________________|_        | |
   // |       |                            |       | |
   // |      _|____________________________|_      | |_ top stack.
   // |     | selected / shallowest workspace|     | |
   // |     |                                |     | |
   // |     |                                |_____|_|
   // |     |                                |     |
   // |     |                                |     |
   // |    _|________________________________|_    |
   // |   |           deepest workspace        |___|_
   // |  _|____________________________________|_  | |_ bottom stack.
   // | |           shallowest workspace         |_|_|
   // |_|________________________________________|_|
   // The selected workspace is the most visible workspace. It is the workspace
   // which will be activated if the user does not do any more cycling.
   bool in_top_stack = (offset_from_selected <= 0);
 
-  // Give workspaces with offsets below |kMinVisibleOffsetFromSelected| the
-  // same transform as the workspace at |kMinVisibleOffsetFromSelected|. As
-  // the workspace at |kMinVisibleOffsetFromSelected| completely occludes
-  // these extra workspaces, they can be hidden.
-  // |kMaxVisibleOffsetFromSelected| is dealt with similarly.
-  if (offset_from_selected < kMinVisibleOffsetFromSelected)
-    offset_from_selected = kMinVisibleOffsetFromSelected;
-  else if (offset_from_selected > kMaxVisibleOffsetFromSelected)
-    offset_from_selected = kMaxVisibleOffsetFromSelected;
+  int min_visible_offset_from_selected = GetMinVisibleOffsetFromSelected();
+  int max_visible_offset_from_selected = GetMaxVisibleOffsetFromSelected();
 
-  double scale = kSelectedWorkspaceScale;
+  // Give workspaces at hidden offsets the transform of the workspace at the
+  // nearest visible offset. This is needed to produce a valid result when
+  // interpolating between the values of GetTargetTransformForOffset() for a
+  // visible and hidden offset.
+  if (offset_from_selected < min_visible_offset_from_selected)
+    offset_from_selected = min_visible_offset_from_selected;
+  else if (offset_from_selected > max_visible_offset_from_selected)
+    offset_from_selected = max_visible_offset_from_selected;
+
+  double selected_scale = Config::GetDouble(Config::SELECTED_SCALE);
+
+  double scale = selected_scale;
   if (in_top_stack) {
+    double min_scale = Config::GetDouble(Config::MIN_SCALE);
     scale -= static_cast<double>(offset_from_selected) /
-        kMinVisibleOffsetFromSelected *
-        (kSelectedWorkspaceScale - kMinTopStackScale);
+        min_visible_offset_from_selected * (selected_scale - min_scale);
   } else {
+    double max_scale = Config::GetDouble(Config::MAX_SCALE);
     scale += static_cast<double>(offset_from_selected) /
-        kMaxVisibleOffsetFromSelected *
-        (kMaxBottomStackScale - kSelectedWorkspaceScale);
+        max_visible_offset_from_selected * (max_scale - selected_scale);
   }
 
-  // Compute the workspace's y offset. As abs(|offset_from_selected|) increases,
-  // the amount of the top of the workspace which is visible from beneath the
-  // shallower workspaces decreases exponentially.
+  // Compute the workspace's y offset.
   double y_offset = 0;
-  if (in_top_stack) {
-    const double kTopStackYOffsets[-kMinVisibleOffsetFromSelected + 1] =
-        { 40, 28, 20 };
-    y_offset = kTopStackYOffsets[
-        static_cast<size_t>(std::abs(offset_from_selected))];
+  if (offset_from_selected == 0) {
+    y_offset = Config::GetDouble(Config::SELECTED_Y_OFFSET);
   } else {
-    const double kBottomStackYOffsets[kMaxVisibleOffsetFromSelected] =
-        { -40, -32, -20 };
-    y_offset = maximized_bounds_.height() +
-        kBottomStackYOffsets[static_cast<size_t>(offset_from_selected - 1)];
+    Config::Property y_offsets_property;
+    if (in_top_stack) {
+      y_offsets_property = Config::DEEPER_THAN_SELECTED_Y_OFFSETS;
+    } else {
+      y_offsets_property = Config::SHALLOWER_THAN_SELECTED_Y_OFFSETS;
+      y_offset = maximized_bounds_.height();
+    }
+    const base::ListValue& y_offsets = Config::GetListValue(y_offsets_property);
+    size_t y_offset_index = static_cast<size_t>(
+        std::abs(offset_from_selected) - 1);
+    DCHECK_GT(y_offsets.GetSize(), y_offset_index);
+    double y_offset_config_value = 0;
+    y_offsets.GetDouble(y_offset_index, &y_offset_config_value);
+    y_offset += y_offset_config_value;
   }
 
   // Center the workspace horizontally.
   double x_offset = maximized_bounds_.width() * (1 - scale) / 2;
 
   gfx::DecomposedTransform transform;
   transform.translate[0] = x_offset;
   transform.translate[1] = y_offset;
   transform.scale[0] = scale;
   transform.scale[1] = scale;
   return transform;
 }
 
 float StyleCalculator::GetTargetBrightnessForOffset(
     int offset_from_selected) const {
   int max_visible_distance_from_selected = std::max(
-      std::abs(kMinVisibleOffsetFromSelected), kMaxVisibleOffsetFromSelected);
-  return kMinBrightness * std::min(
+      std::abs(GetMinVisibleOffsetFromSelected()),
+      GetMaxVisibleOffsetFromSelected());
+  return Config::GetDouble(Config::MIN_BRIGHTNESS) * std::min(
       1.0,
       static_cast<double>(std::abs(offset_from_selected)) /
           max_visible_distance_from_selected);
 }
 
 bool StyleCalculator::GetTargetVisibilityForOffset(
     int offset_from_selected,
     size_t workspace_index) const {
   // The workspace at the highest possible index is the shallowest workspace
   // out of both stacks and is always visible.
-  // The workspace at |kMaxVisibleWorkspaceFromSelected| is hidden because
-  // it has the same transform as the shallowest workspace and is completely
+  // The workspace at |GetMaxVisibleOffsetFromSelected()| is hidden because it
+  // has the same transform as the shallowest workspace and is completely
   // occluded by it.
   if (workspace_index == num_workspaces_ - 1)
     return true;
 
-  return offset_from_selected >= kMinVisibleOffsetFromSelected &&
-      offset_from_selected < kMaxVisibleOffsetFromSelected;
+  return offset_from_selected >= GetMinVisibleOffsetFromSelected() &&
+      offset_from_selected < GetMaxVisibleOffsetFromSelected();
+}
+
+int StyleCalculator::GetMinVisibleOffsetFromSelected() const {
+  const base::ListValue& y_offsets = Config::GetListValue(
+      Config::DEEPER_THAN_SELECTED_Y_OFFSETS);
+  // Hide workspaces for which there is no y offset specified.
+  return -y_offsets.GetSize();
+}
+
+int StyleCalculator::GetMaxVisibleOffsetFromSelected() const {
+  const base::ListValue& y_offsets = Config::GetListValue(
+      Config::SHALLOWER_THAN_SELECTED_Y_OFFSETS);
+  // Hide workspaces for which there is no y offset specified.
+  return y_offsets.GetSize();
 }
 
 WorkspaceCyclerAnimator::WorkspaceCyclerAnimator(Delegate* delegate)
     : delegate_(delegate),
       initial_active_workspace_index_(0),
       selected_workspace_index_(0),
       scroll_delta_(0),
       animation_type_(NONE),
       launcher_background_controller_(NULL),
       style_calculator_(NULL) {
@@ skipping 40 matching lines @@
     ui::Layer* layer = window->layer();
 
     gfx::Transform transform;
     float brightness = 0.0f;
     style_calculator_->GetStoppedTargetProperties(selected_workspace_index_, i,
         &transform, &brightness, NULL);
     layer->SetTransform(transform);
     layer->SetLayerBrightness(brightness);
   }
 
+  int start_cycler_animation_duration = static_cast<int>(Config::GetDouble(
+      Config::START_CYCLER_ANIMATION_DURATION));
+
   scroll_delta_ = 0;
   animation_type_ = CYCLER_START;
-  AnimateToUpdatedState(kStartCyclerAnimationDuration);
+  AnimateToUpdatedState(start_cycler_animation_duration);
 
   aura::Window* background = GetDesktopBackground();
   if (background) {
     ui::Layer* layer = background->layer();
 
     if (!background->IsVisible()) {
       background->Show();
       layer->SetOpacity(0.0f);
     }
 
     {
       ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
       settings.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
-          kStartCyclerAnimationDuration));
+          start_cycler_animation_duration));
 
-      layer->SetOpacity(kBackgroundOpacity);
+      layer->SetOpacity(Config::GetDouble(Config::BACKGROUND_OPACITY));
     }
   }
 
   // Create a window to simulate a fully opaque launcher. This prevents
   // workspaces from showing from behind the launcher.
   CreateLauncherBackground();
 }
 
 void WorkspaceCyclerAnimator::AnimateStoppingCycler() {
   if (scroll_delta_ != 0) {
     // Completely select the workspace at |selected_workspace_index_|.
     int animation_duration = GetAnimationDurationForChangeInScrollDelta(
         -scroll_delta_);
     scroll_delta_ = 0;
     animation_type_ = CYCLER_COMPLETELY_SELECT;
     AnimateToUpdatedState(animation_duration);
     return;
   }
 
+  int stop_cycler_animation_duration = static_cast<int>(Config::GetDouble(
+      Config::STOP_CYCLER_ANIMATION_DURATION));
+
   animation_type_ = CYCLER_END;
-  AnimateToUpdatedState(kStopCyclerAnimationDuration);
+  AnimateToUpdatedState(stop_cycler_animation_duration);
 
   aura::Window* background = GetDesktopBackground();
   if (background) {
     ui::Layer* layer = background->layer();
     ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
-        kStopCyclerAnimationDuration));
+        stop_cycler_animation_duration));
 
     layer->SetOpacity((selected_workspace_index_ == 0) ? 1.0f : 0.0f);
   }
 }
 
 void WorkspaceCyclerAnimator::AbortAnimations() {
   StopObservingImplicitAnimations();
   animation_type_ = NONE;
   CyclerStopped(initial_active_workspace_index_);
 }
 
-void WorkspaceCyclerAnimator::AnimateCyclingByScrollDelta(float scroll_delta) {
-  if (scroll_delta == 0.0f)
+void WorkspaceCyclerAnimator::AnimateCyclingByScrollDelta(double scroll_delta) {
+  if (scroll_delta == 0)
     return;
 
   // Drop any updates received while an animation is running.
   // TODO(pkotwicz): Do something better.
   if (animation_type_ != NONE)
     return;
 
   if (ui::IsNaturalScrollEnabled())
     scroll_delta *= -1;
 
   double old_scroll_delta = scroll_delta_;
   scroll_delta_ += scroll_delta;
 
+  double scroll_distance_to_cycle_to_next_workspace = Config::GetDouble(
+      Config::SCROLL_DISTANCE_TO_CYCLE_TO_NEXT_WORKSPACE);
+
   double min_scroll_delta = -1 *
       static_cast<double>(selected_workspace_index_) *
-      kScrollAmountToCycleToNextWorkspace;
+      scroll_distance_to_cycle_to_next_workspace;
   double max_scroll_delta = static_cast<double>(
       workspaces_.size() - 1 - selected_workspace_index_) *
-      kScrollAmountToCycleToNextWorkspace;
+      scroll_distance_to_cycle_to_next_workspace;
 
   if (scroll_delta_ < min_scroll_delta)
     scroll_delta_ = min_scroll_delta;
   else if (scroll_delta_ > max_scroll_delta)
     scroll_delta_ = max_scroll_delta;
 
   if (scroll_delta_ == old_scroll_delta)
     return;
 
   // Set the selected workspace to the workspace that the user is closest to
   // selecting completely. A workspace is completely selected when the user
   // has scrolled the exact amount to select the workspace with no undershoot /
   // overshoot.
   int workspace_change = floor(scroll_delta_ /
-      kScrollAmountToCycleToNextWorkspace + .5);
+      scroll_distance_to_cycle_to_next_workspace + .5);
   selected_workspace_index_ += workspace_change;
 
   // Set |scroll_delta_| to the amount of undershoot / overshoot.
-  scroll_delta_ -= workspace_change * kScrollAmountToCycleToNextWorkspace;
+  scroll_delta_ -= workspace_change *
+      scroll_distance_to_cycle_to_next_workspace;
 
   int animation_duration = GetAnimationDurationForChangeInScrollDelta(
       scroll_delta_ - old_scroll_delta);
 
   animation_type_ = CYCLER_UPDATE;
   AnimateToUpdatedState(animation_duration);
 }
 
 void WorkspaceCyclerAnimator::AnimateToUpdatedState(int animation_duration) {
   DCHECK_NE(NONE, animation_type_);
@@ skipping 101 matching lines @@
   } else {
     window->Hide();
   }
 
   layer->SetTransform(target_transform);
   layer->SetLayerBrightness(target_brightness);
 }
 
 int WorkspaceCyclerAnimator::GetAnimationDurationForChangeInScrollDelta(
     double change) const {
-  return static_cast<int>(
-      fabs(change) * kCyclerStepAnimationDurationRatio);
+  double ratio = Config::GetDouble(
+      Config::CYCLER_STEP_ANIMATION_DURATION_RATIO);
+  return static_cast<int>(fabs(change) * ratio);
 }
 
 void WorkspaceCyclerAnimator::CreateLauncherBackground() {
   if (screen_bounds_ == maximized_bounds_)
     return;
 
   aura::Window* random_workspace_window = workspaces_[0]->window();
   ash::Launcher* launcher = ash::Launcher::ForWindow(random_workspace_window);
   aura::Window* launcher_window = launcher->widget()->GetNativeWindow();
 
@@ skipping 50 matching lines @@
     MessageLoopForUI::current()->PostTask(
         FROM_HERE,
         base::Bind(&WorkspaceCyclerAnimator::NotifyDelegate,
                    AsWeakPtr(),
                    completed_animation));
   }
 }
 
 }  // namespace internal
 }  // namespace ash