athena: Allow scrolling the window list in overview mode.

athena/wm/window_overview_mode.cc

 // Copyright 2014 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 "athena/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/core/shadow.h"
 
 namespace {
 
+const float kEpsilon = 1e-3f;

[oshima, 2014/06/13 05:26:50]

nit: move this to DoScroll() ?

[sadrul, 2014/06/13 14:00:08]

Done.

+
 struct WindowOverviewState {
   // The transform for when the window is at the topmost position.
   gfx::Transform top;
 
   // The transform for when the window is at the bottom-most position.
   gfx::Transform bottom;
 
   // The current overview state of the window. 0.f means the window is at the
   // topmost position. 1.f means the window is at the bottom-most position.
   float progress;
@@ skipping 102 matching lines @@
          ++iter, ++index) {
       aura::Window* window = (*iter);
 
       gfx::Transform top_transform;
       int top = (window_count - index - 1) * kGapBetweenWindowsTop;
       float x_translate = container_size.width() * (1 - kMinScale) / 2.;
       top_transform.Translate(x_translate, top);
       top_transform.Scale(kMinScale, kMinScale);
 
       gfx::Transform bottom_transform;
-      int bottom = container_size.height() - (index * kGapBetweenWindowsBottom);
+      int bottom = GetScrollableHeight() - (index * kGapBetweenWindowsBottom);
       x_translate = container_size.width() * (1 - kMaxScale) / 2.;
       bottom_transform.Translate(x_translate, bottom - window->bounds().y());
       bottom_transform.Scale(kMaxScale, kMaxScale);
 
       WindowOverviewState* state = new WindowOverviewState;
       state->top = top_transform;
       state->bottom = bottom_transform;
       state->progress = 0.f;
       state->shadow = CreateShadowForWindow(window);
       window->SetProperty(kWindowOverviewState, state);
@@ skipping 54 matching lines @@
     }
     if (!targeter)
       return NULL;
     aura::Window* target = static_cast<aura::Window*>(
         targeter->FindTargetForLocatedEvent(container_, event));
     while (target && target->parent() != container_)
       target = target->parent();
     return target;
   }
 
+  // Scroll the window list by |delta_y| amount. |delta_y| is negative when
+  // scrolling up; and positive when scrolling down.
+  void DoScroll(float delta_y) {
+    aura::Window::Windows windows = container_->children();
+    float delta_y_p = std::abs(delta_y) / GetScrollableHeight();
+    if (delta_y < 0) {
+      // Scroll up. Start with the top-most (i.e. behind-most in terms of
+      // z-index) window, and try to scroll them up.
+      for (aura::Window::Windows::iterator iter = windows.begin();
+           delta_y_p > kEpsilon && iter != windows.end();
+           ++iter) {
+        aura::Window* window = (*iter);
+        WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
+        if (state->progress > kEpsilon) {
+          // It is possible to scroll |window| up. Scroll it up, and update
+          // |delta_y_p| for the next window.
+          float apply = delta_y_p * state->progress;
+          SetWindowProgress(window, std::max(0.f, state->progress - apply * 3));
+          delta_y_p -= apply;
+        }
+      }
+    } else {
+      // Scroll down. Start with the bottom-most (i.e. front-most in terms of
+      // z-index) window, and try to scroll them down.
+      for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
+           delta_y_p > kEpsilon && iter != windows.rend();
+           ++iter) {
+        aura::Window* window = (*iter);
+        WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
+        if (1.f - state->progress > kEpsilon) {
+          // It is possible to scroll |window| down. Scroll it down, and update
+          // |delta_y_p| for the next window.
+          SetWindowProgress(window, std::min(1.f, state->progress + delta_y_p));
+          delta_y_p /= 2.f;
+        }
+      }
+    }
+  }
+
+  int GetScrollableHeight() const {
+    const float kScrollableFraction = 0.65f;
+    return container_->bounds().height() * kScrollableFraction;
+  }
+
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
-    if (mouse->type() != ui::ET_MOUSE_PRESSED)
-      return;
-    aura::Window* select = SelectWindowAt(mouse);
-    if (select) {
-      mouse->SetHandled();
-      delegate_->OnSelectWindow(select);
+    if (mouse->type() == ui::ET_MOUSE_PRESSED) {
+      aura::Window* select = SelectWindowAt(mouse);
+      if (select) {
+        mouse->SetHandled();
+        delegate_->OnSelectWindow(select);
+      }
+    } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
+      DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
     }
   }
 
+  virtual void OnScrollEvent(ui::ScrollEvent* scroll) OVERRIDE {
+    if (scroll->type() == ui::ET_SCROLL)
+      DoScroll(scroll->y_offset());
+  }
+
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
-    if (gesture->type() != ui::ET_GESTURE_TAP)
-      return;
-    aura::Window* select = SelectWindowAt(gesture);
-    if (select) {
-      gesture->SetHandled();
-      delegate_->OnSelectWindow(select);
+    if (gesture->type() == ui::ET_GESTURE_TAP) {
+      aura::Window* select = SelectWindowAt(gesture);
+      if (select) {
+        gesture->SetHandled();
+        delegate_->OnSelectWindow(select);
+      }
+    } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
+      DoScroll(gesture->details().scroll_y());
     }
   }
 
   aura::Window* container_;
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* window,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(window, delegate));
 }
 
 }  // namespace athena