Moves home card background to HomeCardView.

athena/home/home_card_impl.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/home/home_card_impl.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/env/public/athena_env.h"
@@ skipping 109 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
 };
 
 // The container view of home card contents of each state.
 class HomeCardView : public views::WidgetDelegateView,
                      public AthenaStartPageView::Observer {
  public:
   HomeCardView(app_list::AppListViewDelegate* view_delegate,
                aura::Window* container,
                HomeCardGestureManager::Delegate* gesture_delegate)
-      : minimized_background_(new views::View()),
+      : background_(new views::View),
+        main_view_(new AthenaStartPageView(view_delegate)),
+        minimized_background_(new views::View()),
         drag_indicator_(new views::View()),
-        main_view_(new AthenaStartPageView(view_delegate)),
         gesture_delegate_(gesture_delegate) {
+    background_->set_background(
+        views::Background::CreateVerticalGradientBackground(SK_ColorLTGRAY,
+                                                            SK_ColorWHITE));
+    background_->SetPaintToLayer(true);
+    background_->SetFillsBoundsOpaquely(false);
+    AddChildView(background_);
+
     // Ideally AppListMainView should be used here and have AthenaStartPageView
     // as its child view, so that custom pages and apps grid are available in
     // the home card.
     // TODO(mukai): make it so after the detailed UI has been fixed.
     main_view_->AddObserver(this);
     AddChildView(main_view_);
 
     minimized_background_->set_background(
         views::Background::CreateSolidBackground(
             SkColorSetA(SK_ColorBLACK, 256 * kMinimizedHomeOpacity)));
@@ skipping 12 matching lines @@
 
   void SetStateProgress(HomeCard::State from_state,
                         HomeCard::State to_state,
                         float progress) {
     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
     GetFocusManager()->ClearFocus();
     if (from_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(1.0f - progress);
     else if (to_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(progress);
+
+    float background_opacity = 1.0f;
     if (from_state == HomeCard::VISIBLE_MINIMIZED ||
         to_state == HomeCard::VISIBLE_MINIMIZED) {
-      minimized_background_->layer()->SetOpacity(
-          (to_state == HomeCard::VISIBLE_MINIMIZED) ? progress
-                                                    : (1.0f - progress));
+      background_opacity = (from_state == HomeCard::VISIBLE_MINIMIZED)
+                               ? progress
+                               : (1.0f - progress);
     }
+    background_->layer()->SetOpacity(background_opacity);
+    minimized_background_->layer()->SetOpacity(1.0f - background_opacity);
+
+    int background_height = kHomeCardHeight;
+    if (from_state == HomeCard::VISIBLE_CENTERED ||
+        to_state == HomeCard::VISIBLE_CENTERED) {
+      gfx::Rect window_bounds = GetWidget()->GetWindowBoundsInScreen();
+      background_height = window_bounds.height() - window_bounds.y();
+    }
+    gfx::Transform background_transform;
+    background_transform.Scale(
+        SK_MScalar1,
+        SkIntToMScalar(background_height) / SkIntToMScalar(height()));
+    background_->layer()->SetTransform(background_transform);
 
     gfx::Rect from_bounds = GetDragIndicatorBounds(from_state);
     gfx::Rect to_bounds = GetDragIndicatorBounds(to_state);
     if (from_bounds != to_bounds) {
       DCHECK_EQ(from_bounds.size().ToString(), to_bounds.size().ToString());
       drag_indicator_->SetBoundsRect(
           gfx::Tween::RectValueBetween(progress, from_bounds, to_bounds));
     }
   }
 
   void SetStateWithAnimation(HomeCard::State state,
                              gfx::Tween::Type tween_type) {
-    float minimized_target_opacity_for_state =
+    float minimized_opacity =
         (state == HomeCard::VISIBLE_MINIMIZED) ? 1.0f : 0.0f;
-    if (minimized_target_opacity_for_state !=
+    if (minimized_opacity !=
         minimized_background_->layer()->GetTargetOpacity()) {
       ui::ScopedLayerAnimationSettings settings(
           minimized_background_->layer()->GetAnimator());
       settings.SetTweenType(gfx::Tween::EASE_IN);
-      minimized_background_->layer()->SetOpacity(
-          minimized_target_opacity_for_state);
+      minimized_background_->layer()->SetOpacity(minimized_opacity);
     }
+
+    gfx::Transform background_transform;
+    if (state != HomeCard::VISIBLE_CENTERED) {
+      background_transform.Scale(
+          SK_MScalar1,
+          SkIntToMScalar(kHomeCardHeight) / SkIntToMScalar(height()));
+    }
+    float background_opacity = 1.0f - minimized_opacity;
+    if (background_->layer()->GetTargetTransform() != background_transform ||
+        background_->layer()->GetTargetOpacity() != background_opacity) {
+      ui::ScopedLayerAnimationSettings settings(
+          background_->layer()->GetAnimator());
+      settings.SetTweenType(tween_type);
+      background_->layer()->SetTransform(background_transform);
+      background_->layer()->SetOpacity(background_opacity);
+    }
+
     if (state == HomeCard::VISIBLE_CENTERED)
       main_view_->RequestFocusOnSearchBox();
     else
       GetWidget()->GetFocusManager()->ClearFocus();
 
     {
       ui::ScopedLayerAnimationSettings settings(
           drag_indicator_->layer()->GetAnimator());
       settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
       drag_indicator_->SetBoundsRect(GetDragIndicatorBounds(state));
@@ skipping 34 matching lines @@
         kHomeCardDragIndicatorMarginHeight,
         kHomeCardDragIndicatorWidth,
         kHomeCardDragIndicatorHeight);
     if (state == HomeCard::VISIBLE_CENTERED)
       drag_indicator_bounds.Offset(0, kSystemUIHeight);
     return drag_indicator_bounds;
   }
 
   void Layout() override {
     gfx::Rect contents_bounds = GetContentsBounds();
+    background_->SetBoundsRect(contents_bounds);
     main_view_->SetBoundsRect(contents_bounds);
     minimized_background_->SetBoundsRect(contents_bounds);
     drag_indicator_->SetBoundsRect(
         GetDragIndicatorBounds(HomeCard::Get()->GetState()));
   }
 
  private:
   // views::WidgetDelegate:
   views::View* GetContentsView() override { return this; }
 
   // AthenaStartPageView::Observer:
   void OnLayoutStateChanged(float new_state) override {
     if (new_state == 1.0f)
       HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED);
   }
 
+  views::View* background_;
+  AthenaStartPageView* main_view_;
   views::View* minimized_background_;
   views::View* drag_indicator_;
-  AthenaStartPageView* main_view_;
   HomeCard::State state_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
 
 HomeCardImpl::HomeCardImpl(scoped_ptr<AppModelBuilder> model_builder,
                            scoped_ptr<SearchControllerFactory> search_factory)
     : model_builder_(model_builder.Pass()),
@@ skipping 183 matching lines @@
   instance = nullptr;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena