athena: Add shadows to the windows 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 {
 
 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;
 
@@ skipping 65 matching lines @@
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))) {
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
+    AddShadowsForWindows();
   }
 
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
 
     aura::Window::Windows windows = container_->children();
     if (windows.empty())
       return;
     std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
   }
@@ skipping 65 matching lines @@
       {
         ui::ScopedLayerAnimationSettings settings(animator);
         settings.SetPreemptionStrategy(
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
         settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
         SetWindowProgress(window, progress);
       }
     }
   }
 
+  void AddShadowsForWindows() {
+    aura::Window::Windows windows = container_->children();
+    if (windows.empty())
+      return;
+    std::for_each(
+        windows.begin(),
+        windows.end(),
+        std::bind1st(std::mem_fun(&WindowOverviewModeImpl::AddShadowForWindow),
+                     this));
+  }
+
+  void AddShadowForWindow(aura::Window* window) {
+    wm::Shadow* shadow = new wm::Shadow();
+    shadows_.push_back(shadow);
+    shadow->Init(wm::Shadow::STYLE_ACTIVE);
+    shadow->SetContentBounds(gfx::Rect(window->bounds().size()));
+    shadow->layer()->SetVisible(true);
+    window->layer()->Add(shadow->layer());
+  }
+
   aura::Window* SelectWindowAt(ui::LocatedEvent* event) {
     CHECK_EQ(container_, event->target());
     // Find the old targeter to find the target of the event.
     ui::EventTarget* window = container_;
     ui::EventTargeter* targeter = scoped_targeter_->old_targeter();
     while (!targeter && window->GetParentTarget()) {
       window = window->GetParentTarget();
       targeter = window->GetEventTargeter();
     }
     if (!targeter)
@@ skipping 22 matching lines @@
     aura::Window* select = SelectWindowAt(gesture);
     if (select) {
       gesture->SetHandled();
       delegate_->OnSelectWindow(select);
     }
   }
 
   aura::Window* container_;
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
+  ScopedVector<wm::Shadow> shadows_;

[oshima, 2014/06/12 19:15:24]

can't you store the shadow in the state object? 

[sadrul, 2014/06/12 19:37:51]

Good idea! done.

 
   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