aura: Draw drop shadows under browsers and menus.

ui/aura/window.cc

 // Copyright (c) 2011 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/layout_manager.h"
+#include "ui/aura/shadow.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_types.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 Window::Window(WindowDelegate* delegate)
     : type_(WINDOW_TYPE_UNKNOWN),
       delegate_(delegate),
       parent_(NULL),
       transient_parent_(NULL),
       id_(-1),
       user_data_(NULL),
-      stops_event_propagation_(false) {
+      stops_event_propagation_(false),
+      show_shadow_(false) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying();
 
   // Let the root know so that it can remove any references to us.
   Desktop* desktop = GetDesktop();
   if (desktop)
@@ skipping 23 matching lines @@
   if (parent_)
     parent_->RemoveChild(this);
 
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroyed(this));
 }
 
 void Window::Init(ui::Layer::LayerType layer_type) {
   layer_.reset(new ui::Layer(Desktop::GetInstance()->compositor(), layer_type));
   layer_->SetVisible(false);
   layer_->set_delegate(this);
+
+  if (show_shadow_)
+    InitShadow();
 }
 
 void Window::SetType(WindowType type) {
   // Cannot change type after the window is initialized.
   DCHECK(!layer());
   type_ = type;
 }
 
 void Window::Show() {
   SetVisible(true);
@@ skipping 96 matching lines @@
       std::find(children_.begin(), children_.end(), other) - children_.begin();
   if (child_i > other_i)
     return;  // Already in front of |other|.
 
   // Reorder children.
   children_.erase(children_.begin() + child_i);
   children_.insert(children_.begin() + other_i, child);
 
   // Reorder the layer.
   layer()->MoveAbove(child->layer(), other->layer());
+  if (child->shadow_.get())
+    layer()->MoveAbove(child->shadow_->layer(), other->layer());
 
   // Move any transient children that share the same parent to be in front of
   // 'child'.
   Window* last_transient = child;
   for (Windows::iterator i = child->transient_children_.begin();
        i != child->transient_children_.end(); ++i) {
     Window* transient_child = *i;
     if (transient_child->parent_ == this) {
       MoveChildAbove(transient_child, last_transient);
       last_transient = transient_child;
     }
   }
 }
 
 bool Window::CanActivate() const {
   return IsVisible() && (!delegate_ || delegate_->ShouldActivate(NULL));
 }
 
 void Window::AddChild(Window* child) {
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChild(child);
   child->parent_ = this;
+
+  if (child->shadow_.get())
+    layer_->Add(child->shadow_->layer());
   layer_->Add(child->layer_.get());
+
   children_.push_back(child);
   if (layout_manager_.get())
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
 }
 
 void Window::AddTransientChild(Window* child) {
   if (child->transient_parent_)
     child->transient_parent_->RemoveTransientChild(child);
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
@@ skipping 15 matching lines @@
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   if (layout_manager_.get())
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
   aura::Window* desktop = child->GetDesktop();
   child->parent_ = NULL;
   if (desktop)
     desktop->WindowDetachedFromDesktop(child);
   layer_->Remove(child->layer_.get());
+  if (child->shadow_.get())
+    layer_->Remove(child->shadow_->layer());
   children_.erase(i);
 }
 
 Window* Window::GetChildById(int id) {
   return const_cast<Window*>(const_cast<const Window*>(this)->GetChildById(id));
 }
 
 const Window* Window::GetChildById(int id) const {
   Windows::const_iterator i;
   for (i = children_.begin(); i != children_.end(); ++i) {
@@ skipping 135 matching lines @@
   if (iter == prop_map_.end())
     return NULL;
   return iter->second;
 }
 
 int Window::GetIntProperty(const char* name) const {
   return static_cast<int>(reinterpret_cast<intptr_t>(
       GetProperty(name)));
 }
 
+void Window::SetShadowVisible(bool visible) {
+  show_shadow_ = visible;
+  if (visible && !shadow_.get() && layer())
+    InitShadow();
+  else if (shadow_.get())
+    shadow_->layer()->SetVisible(visible);
+}
+
 Desktop* Window::GetDesktop() {
   return parent_ ? parent_->GetDesktop() : NULL;
 }
 
 void Window::WindowDetachedFromDesktop(aura::Window* window) {
 }
 
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   const gfx::Rect old_bounds = layer_->GetTargetBounds();
 
   // Always need to set the layer's bounds -- even if it is to the same thing.
   // This may cause important side effects such as stopping animation.
   layer_->SetBounds(new_bounds);
+  if (shadow_.get())
+    shadow_->SetContentBounds(new_bounds);
 
   // If we're not changing the effective bounds, then we can bail early and skip
   // notifying our listeners.
   if (old_bounds == new_bounds)
     return;
 
   if (layout_manager_.get())
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, new_bounds);
 }
 
 void Window::SetVisible(bool visible) {
   if (visible == layer_->visible())
     return;  // No change.
 
   bool was_visible = IsVisible();
   layer_->SetVisible(visible);
   bool is_visible = IsVisible();
   if (was_visible != is_visible) {
     SchedulePaint();
     if (delegate_)
       delegate_->OnWindowVisibilityChanged(is_visible);
   }
+
+  if (shadow_.get())
+    shadow_->layer()->SetVisible(show_shadow_ && visible);
+
   if (parent_ && parent_->layout_manager_.get())
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanged(this, visible));
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
@@ skipping 28 matching lines @@
     if (match)
       return match;
 
     if (for_event_handling && child->StopsEventPropagation())
       break;
   }
 
   return delegate_ ? this : NULL;
 }
 
+void Window::InitShadow() {
+  DCHECK(layer());
+
+  shadow_.reset(new internal::Shadow());
+  shadow_->Init();
+  if (parent_) {
+    // Stack the shadow directly below |layer_|.
+    parent_->layer_->Add(shadow_->layer());
+    // TODO(derat): Add a MoveBelow() method and use that instead (although we
+    // then run the risk of things getting stacked between a window and its
+    // shadow).
+    parent_->layer_->MoveAbove(shadow_->layer(), layer_.get());
+    parent_->layer_->MoveAbove(layer_.get(), shadow_->layer());
+  }
+
+  shadow_->SetContentBounds(bounds());
+  shadow_->layer()->SetVisible(show_shadow_);
+}
+
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura