1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "ui/wm/core/shadow.h"
7 #include "third_party/skia/include/core/SkBitmap.h"
8 #include "ui/base/resource/resource_bundle.h"
9 #include "ui/compositor/layer.h"
10 #include "ui/compositor/scoped_layer_animation_settings.h"
11 #include "ui/resources/grit/ui_resources.h"
15 // The opacity used for active shadow when animating between
16 // inactive/active shadow.
17 const float kInactiveShadowAnimationOpacity
= 0.2f
;
19 // Shadow aperture for different styles.
20 // Note that this may be greater than interior inset to allow shadows with
21 // curved corners that extend inwards beyond a window's borders.
22 const int kActiveInteriorAperture
= 134;
23 const int kInactiveInteriorAperture
= 134;
24 const int kSmallInteriorAperture
= 9;
26 // Interior inset for different styles.
27 const int kActiveInteriorInset
= 64;
28 const int kInactiveInteriorInset
= 64;
29 const int kSmallInteriorInset
= 4;
31 // Duration for opacity animation in milliseconds.
32 const int kShadowAnimationDurationMs
= 100;
34 int GetShadowApertureForStyle(wm::Shadow::Style style
) {
36 case wm::Shadow::STYLE_ACTIVE
:
37 return kActiveInteriorAperture
;
38 case wm::Shadow::STYLE_INACTIVE
:
39 return kInactiveInteriorAperture
;
40 case wm::Shadow::STYLE_SMALL
:
41 return kSmallInteriorAperture
;
46 int GetInteriorInsetForStyle(wm::Shadow::Style style
) {
48 case wm::Shadow::STYLE_ACTIVE
:
49 return kActiveInteriorInset
;
50 case wm::Shadow::STYLE_INACTIVE
:
51 return kInactiveInteriorInset
;
52 case wm::Shadow::STYLE_SMALL
:
53 return kSmallInteriorInset
;
62 Shadow::Shadow() : style_(STYLE_ACTIVE
), interior_inset_(0) {
68 void Shadow::Init(Style style
) {
71 layer_
.reset(new ui::Layer(ui::LAYER_NOT_DRAWN
));
72 shadow_layer_
.reset(new ui::Layer(ui::LAYER_NINE_PATCH
));
73 layer()->Add(shadow_layer_
.get());
75 UpdateImagesForStyle();
76 shadow_layer_
->set_name("Shadow");
77 shadow_layer_
->SetVisible(true);
78 shadow_layer_
->SetFillsBoundsOpaquely(false);
81 void Shadow::SetContentBounds(const gfx::Rect
& content_bounds
) {
82 content_bounds_
= content_bounds
;
86 void Shadow::SetStyle(Style style
) {
90 Style old_style
= style_
;
93 // Stop waiting for any as yet unfinished implicit animations.
94 StopObservingImplicitAnimations();
96 // If we're switching to or from the small style, don't bother with
98 if (style
== STYLE_SMALL
|| old_style
== STYLE_SMALL
) {
99 UpdateImagesForStyle();
100 // Make sure the shadow is fully opaque.
101 shadow_layer_
->SetOpacity(1.0f
);
105 // If we're becoming active, switch images now. Because the inactive image
106 // has a very low opacity the switch isn't noticeable and this approach
107 // allows us to use only a single set of shadow images at a time.
108 if (style
== STYLE_ACTIVE
) {
109 UpdateImagesForStyle();
110 // Opacity was baked into inactive image, start opacity low to match.
111 shadow_layer_
->SetOpacity(kInactiveShadowAnimationOpacity
);
115 // Property sets within this scope will be implicitly animated.
116 ui::ScopedLayerAnimationSettings
settings(shadow_layer_
->GetAnimator());
117 settings
.AddObserver(this);
118 settings
.SetTransitionDuration(
119 base::TimeDelta::FromMilliseconds(kShadowAnimationDurationMs
));
122 // Animate the active shadow from kInactiveShadowAnimationOpacity to
124 shadow_layer_
->SetOpacity(1.0f
);
127 // The opacity will be reset to 1.0f when animation is completed.
128 shadow_layer_
->SetOpacity(kInactiveShadowAnimationOpacity
);
131 NOTREACHED() << "Unhandled style " << style_
;
137 void Shadow::OnImplicitAnimationsCompleted() {
138 // If we just finished going inactive, switch images. This doesn't cause
139 // a visual pop because the inactive image opacity is so low.
140 if (style_
== STYLE_INACTIVE
) {
141 UpdateImagesForStyle();
142 // Opacity is baked into inactive image, so set fully opaque.
143 shadow_layer_
->SetOpacity(1.0f
);
147 void Shadow::UpdateImagesForStyle() {
148 ResourceBundle
& res
= ResourceBundle::GetSharedInstance();
152 image
= res
.GetImageNamed(IDR_AURA_SHADOW_ACTIVE
);
155 image
= res
.GetImageNamed(IDR_AURA_SHADOW_INACTIVE
);
158 image
= res
.GetImageNamed(IDR_WINDOW_BUBBLE_SHADOW_SMALL
);
161 NOTREACHED() << "Unhandled style " << style_
;
165 shadow_layer_
->UpdateNinePatchLayerImage(image
.AsImageSkia());
166 image_size_
= image
.Size();
167 interior_inset_
= GetInteriorInsetForStyle(style_
);
169 // Image sizes may have changed.
173 void Shadow::UpdateLayerBounds() {
174 // Update bounds based on content bounds and interior inset.
175 gfx::Rect layer_bounds
= content_bounds_
;
176 layer_bounds
.Inset(-interior_inset_
, -interior_inset_
);
177 layer()->SetBounds(layer_bounds
);
178 shadow_layer_
->SetBounds(gfx::Rect(layer_bounds
.size()));
180 // Update the shadow aperture and border for style. Note that border is in
181 // layer space and it cannot exceed the bounds of the layer.
182 int aperture
= GetShadowApertureForStyle(style_
);
183 int aperture_x
= std::min(aperture
, layer_bounds
.width() / 2);
184 int aperture_y
= std::min(aperture
, layer_bounds
.height() / 2);
185 shadow_layer_
->UpdateNinePatchLayerAperture(
186 gfx::Rect(aperture_x
, aperture_y
,
187 image_size_
.width() - aperture_x
* 2,
188 image_size_
.height() - aperture_y
* 2));
189 shadow_layer_
->UpdateNinePatchLayerBorder(
190 gfx::Rect(aperture_x
, aperture_y
, aperture_x
* 2, aperture_y
* 2));