While dragging a window, show a semi-transparent aura window instead of the standard gray phantom wi

ash/wm/workspace/workspace_window_resizer.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_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/display/display_controller.h"
@@ skipping 16 matching lines @@
 #include "ui/gfx/transform.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 // Duration of the animation when snapping the window into place.
 const int kSnapDurationMS = 100;
 
+// The maximum opacity of the drag phantom window.
+const float kMaxOpacity = 0.8f;
+
 // Returns true if should snap to the edge.
 bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
   return distance_from_edge <= grid_size / 2 &&
       distance_from_edge > -grid_size * 2;
 }
 
 // Returns true if Ash has more than one root window.
 bool HasSecondaryRootWindow() {
   return Shell::GetAllRootWindows().size() > 1;
 }
@@ skipping 67 matching lines @@
 
   const bool in_original_root = (window()->GetRootWindow() == current_root);
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root)
     UpdateSnapPhantomWindow(location_in_parent, bounds, grid_size);
   else
     snap_phantom_window_controller_.reset();
 
   // Show a phantom window for dragging in another root window.
   if (HasSecondaryRootWindow())
-    UpdateDragPhantomWindow(bounds);
+    UpdateDragPhantomWindow(bounds, in_original_root);
   else
     drag_phantom_window_controller_.reset();
 
   if (!attached_windows_.empty())
     LayoutAttachedWindows(bounds, grid_size);
   if (bounds != details_.window->bounds())
     details_.window->SetBounds(bounds);
   // WARNING: we may have been deleted.
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
+  window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) {
     if (!GetRestoreBoundsInScreen(details_.window))
       SetRestoreBoundsInParent(details_.window, details_.initial_bounds);
     details_.window->SetBounds(snap_sizer_->target_bounds());
     return;
@@ skipping 29 matching lines @@
 
   ui::ScopedLayerAnimationSettings scoped_setter(
       details_.window->layer()->GetAnimator());
   // Use a small duration since the grid is small.
   scoped_setter.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSnapDurationMS));
   details_.window->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
+  window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
   details_.window->SetBounds(details_.initial_bounds);
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
@@ skipping 238 matching lines @@
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
-void WorkspaceWindowResizer::UpdateDragPhantomWindow(const gfx::Rect& bounds) {
+void WorkspaceWindowResizer::UpdateDragPhantomWindow(const gfx::Rect& bounds,
+                                                     bool in_original_root) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION ||
       !ShouldAllowMouseWarp()) {
     return;
   }
 
   // It's available. Show a phantom window on the display if needed.
   aura::RootWindow* another_root =
       GetAnotherRootWindow(window()->GetRootWindow());
   const gfx::Rect root_bounds_in_screen(another_root->GetBoundsInScreen());
   const gfx::Rect bounds_in_screen =
       ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
-  const gfx::Rect phantom(root_bounds_in_screen.Intersect(bounds_in_screen));
+  const gfx::Rect bounds_in_another_root =
+      root_bounds_in_screen.Intersect(bounds_in_screen);
 
-  if (!phantom.IsEmpty()) {
+  const float fraction_in_another_window =
+      (bounds_in_another_root.width() * bounds_in_another_root.height()) /
+      static_cast<float>(bounds.width() * bounds.height());
+  const float phantom_opacity =
+      !in_original_root ? 1 : (kMaxOpacity * fraction_in_another_window);
+  const float window_opacity =
+      in_original_root ? 1 : (kMaxOpacity * (1 - fraction_in_another_window));
+
+  if (fraction_in_another_window > 0) {
     if (!drag_phantom_window_controller_.get()) {
       drag_phantom_window_controller_.reset(
-          new PhantomWindowController(window()));
-      drag_phantom_window_controller_->Show(phantom);
+          // Always show the drag phantom on the |another_root| window.
+          new PhantomWindowController(window(),
+                                      another_root,
+                                      PhantomWindowController::STYLE_WINDOW));
+      drag_phantom_window_controller_->Show(bounds_in_screen);
     } else {
-      drag_phantom_window_controller_->SetBounds(phantom);  // no animation
+      // No animation.
+      drag_phantom_window_controller_->SetBounds(bounds_in_screen);
     }
+    drag_phantom_window_controller_->SetOpacity(phantom_opacity);
+    window()->layer()->SetOpacity(window_opacity);
   } else {
     drag_phantom_window_controller_.reset();
+    window()->layer()->SetOpacity(1.0f);
   }
 }
 
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
                                                      const gfx::Rect& bounds,
                                                      int grid_size) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE)
       return;
   }
   if (!snap_sizer_.get()) {
     SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     snap_sizer_.reset(
         new SnapSizer(details_.window, location, edge, grid_size));
   } else {
     snap_sizer_->Update(location);
   }
   if (!snap_phantom_window_controller_.get()) {
     snap_phantom_window_controller_.reset(
-        new PhantomWindowController(details_.window));
+        new PhantomWindowController(details_.window,
+                                    NULL,
+                                    PhantomWindowController::STYLE_SHADOW));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
       details_.window->parent(), snap_sizer_->target_bounds()));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
@@ skipping 36 matching lines @@
 }
 
 bool WorkspaceWindowResizer::ShouldAllowMouseWarp() const {
   return (details_.window_component == HTCAPTION) &&
       (window()->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE) &&
       (window()->type() == aura::client::WINDOW_TYPE_NORMAL);
 }
 
 }  // namespace internal
 }  // namespace ash