Enable touch text selection on Athena

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>
 
@@ skipping 81 matching lines @@
                                public ui::EventHandler {
  public:
   WindowOverviewModeImpl(aura::Window* container,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))) {
+    const aura::Window::Windows& children = container->children();
+    for (aura::Window::Windows::const_iterator iter = children.begin();
+         iter != children.end(); iter++) {
+      if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL)
+        windows_.push_back(*iter);
+    }
+
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
   }
 
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
 
-    aura::Window::Windows windows = container_->children();
-    if (windows.empty())
+    if (windows_.empty())
       return;
-    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
+    std::for_each(windows_.begin(), windows_.end(), &RestoreWindowState);
   }
 
  private:
   // Computes the transforms for all windows in both the topmost and bottom-most
   // positions. The transforms are set in the |kWindowOverviewState| property of
   // the windows.
   void ComputeTerminalStatesForAllWindows() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
+    size_t window_count = windows_.size();
     size_t index = 0;
     const gfx::Size container_size = container_->bounds().size();
 
     const int kGapBetweenWindowsBottom = 10;
     const int kGapBetweenWindowsTop = 5;
     const float kMinScale = 0.6f;
     const float kMaxScale = 0.95f;
 
-    for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
-         iter != windows.rend();
+    for (aura::Window::Windows::reverse_iterator iter = windows_.rbegin();
+         iter != windows_.rend();
          ++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 = 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);
     }
   }
 
   // Sets the initial position for the windows for the overview mode.
   void SetInitialWindowStates() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
+    size_t window_count = windows_.size();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
     for (size_t i = 0; i < window_count; ++i) {
       float progress = 0.f;
-      aura::Window* window = windows[window_count - 1 - i];
+      aura::Window* window = windows_[window_count - 1 - i];
       if (i < arraysize(kInitialProgress))
         progress = kInitialProgress[i];
 
       scoped_refptr<ui::LayerAnimator> animator =
           window->layer()->GetAnimator();
 
       // Unset any in-progress animation.
       {
         ui::ScopedLayerAnimationSettings settings(animator);
         settings.SetPreemptionStrategy(
@@ skipping 36 matching lines @@
         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) {
     const float kEpsilon = 1e-3f;
-    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();
+      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();
+      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;
         }
       }
@@ skipping 29 matching lines @@
       if (select) {
         gesture->SetHandled();
         delegate_->OnSelectWindow(select);
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       DoScroll(gesture->details().scroll_y());
     }
   }
 
   aura::Window* container_;
+  aura::Window::Windows windows_;

[oshima, 2014/08/01 20:27:14]

you can just use container's children and property for now.

later, we should have a class (not a just a list of windows) to
maintain/controls the order. 

[mohsen, 2014/08/01 20:44:35]

OK. I think I see what you say. My only concern would be in that case we need to
check the property on all windows on every scroll and it might degrade the
performance. Is that fine?

   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, delegate));
 }
 
 }  // namespace athena