Refactor the home card structure and introduce animation.

athena/home/athena_start_page_view.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/athena_start_page_view.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
@@ skipping 111 matching lines @@
 class SearchBoxContainer : public views::View {
  public:
   explicit SearchBoxContainer(app_list::SearchBoxView* search_box)
       : search_box_(search_box) {
     search_box->set_background(
         new RoundRectBackground(SK_ColorWHITE, kSearchBoxCornerRadius));
     search_box->SetBorder(views::Border::CreateBorderPainter(
         new views::RoundRectPainter(SK_ColorGRAY, kSearchBoxCornerRadius),
         gfx::Insets(kSearchBoxBorderWidth, kSearchBoxBorderWidth,
                     kSearchBoxBorderWidth, kSearchBoxBorderWidth)));
+    SetLayoutManager(new views::FillLayout());
     AddChildView(search_box_);
   }
   virtual ~SearchBoxContainer() {}
 
  private:
   // views::View:
-  virtual void Layout() OVERRIDE {
-    gfx::Rect search_box_bounds = GetContentsBounds();
-    search_box_bounds.ClampToCenteredSize(GetPreferredSize());
-    search_box_->SetBoundsRect(search_box_bounds);
-  }
   virtual gfx::Size GetPreferredSize() const OVERRIDE {
     return gfx::Size(kSearchBoxWidth, kSearchBoxHeight);
   }
 
   // Owned by the views hierarchy.
   app_list::SearchBoxView* search_box_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchBoxContainer);
 };
 
 }  // namespace
 
 namespace athena {
 
+// static
+const char AthenaStartPageView::kViewClassName[] = "AthenaStartPageView";
+
+AthenaStartPageView::LayoutData::LayoutData()
+    : logo_opacity(1.0f),
+      background_opacity(1.0f) {
+}
+
 AthenaStartPageView::AthenaStartPageView(
     app_list::AppListViewDelegate* view_delegate)
     : delegate_(view_delegate),
+      layout_state_(0.0f),
       weak_factory_(this) {
+  background_ = new views::View();
+  background_->set_background(
+      views::Background::CreateSolidBackground(SK_ColorWHITE));
+  background_->SetPaintToLayer(true);
+  background_->SetFillsBoundsOpaquely(false);
+  AddChildView(background_);
+
   logo_ = view_delegate->CreateStartPageWebView(
       gfx::Size(kWebViewWidth, kWebViewHeight));
   logo_->SetPaintToLayer(true);
+  logo_->SetSize(logo_->GetPreferredSize());
   AddChildView(logo_);
 
   search_results_view_ = new app_list::SearchResultListView(
       NULL, view_delegate);
   // search_results_view_'s size will shrink after settings results.
   search_results_height_ = static_cast<views::View*>(
       search_results_view_)->GetHeightForWidth(kSearchBoxWidth);
   search_results_view_->SetResults(view_delegate->GetModel()->results());
 
   search_results_view_->SetVisible(false);
   search_results_view_->SetPaintToLayer(true);
   search_results_view_->SetFillsBoundsOpaquely(false);
   AddChildView(search_results_view_);
 
   app_icon_container_ = new views::View();
   AddChildView(app_icon_container_);
   app_icon_container_->SetPaintToLayer(true);
   app_icon_container_->layer()->SetFillsBoundsOpaquely(false);
   app_icon_container_->SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kHorizontal, 0, 0, kIconMargin));
   app_list::AppListItemList* top_level =
       view_delegate->GetModel()->top_level_item_list();
   for (size_t i = 0; i < std::min(top_level->item_count(), kMaxIconNum); ++i)
     app_icon_container_->AddChildView(new AppIconButton(top_level->item_at(i)));
-
-  search_box_view_ = new app_list::SearchBoxView(this, view_delegate);
-  search_box_view_->set_contents_view(this);
-  search_box_container_ = new SearchBoxContainer(search_box_view_);
-  search_box_container_->SetPaintToLayer(true);
-  search_box_container_->SetFillsBoundsOpaquely(false);
-  AddChildView(search_box_container_);
+  app_icon_container_->SetSize(app_icon_container_->GetPreferredSize());
 
   control_icon_container_ = new views::View();
   control_icon_container_->SetPaintToLayer(true);
   control_icon_container_->SetFillsBoundsOpaquely(false);
   AddChildView(control_icon_container_);
   control_icon_container_->SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kHorizontal, 0, 0, kIconMargin));
   for (size_t i = 0; i < kMaxIconNum; ++i)
     control_icon_container_->AddChildView(new PlaceHolderButton());
+  control_icon_container_->SetSize(control_icon_container_->GetPreferredSize());
+
+  search_box_view_ = new app_list::SearchBoxView(this, view_delegate);
+  search_box_view_->set_contents_view(this);
+  search_box_container_ = new SearchBoxContainer(search_box_view_);
+  search_box_container_->SetPaintToLayer(true);
+  search_box_container_->SetFillsBoundsOpaquely(false);
+  search_box_container_->SetSize(search_box_container_->GetPreferredSize());
+  AddChildView(search_box_container_);
 }
 
 AthenaStartPageView::~AthenaStartPageView() {}
 
 void AthenaStartPageView::RequestFocusOnSearchBox() {
   search_box_view_->search_box()->RequestFocus();
 }
 
+void AthenaStartPageView::SetLayoutState(float layout_state) {
+  layout_state_ = layout_state;
+  Layout();
+}
+
+void AthenaStartPageView::SetLayoutStateWithAnimation(float layout_state) {
+  ui::ScopedLayerAnimationSettings logo(logo_->layer()->GetAnimator());
+  ui::ScopedLayerAnimationSettings search_box(
+      search_box_container_->layer()->GetAnimator());
+  ui::ScopedLayerAnimationSettings icons(
+      app_icon_container_->layer()->GetAnimator());
+  ui::ScopedLayerAnimationSettings controls(
+      control_icon_container_->layer()->GetAnimator());
+
+  logo.SetTweenType(gfx::Tween::EASE_IN_OUT);
+  search_box.SetTweenType(gfx::Tween::EASE_IN_OUT);
+  icons.SetTweenType(gfx::Tween::EASE_IN_OUT);
+  controls.SetTweenType(gfx::Tween::EASE_IN_OUT);
+
+  SetLayoutState(layout_state);
+}
+
+AthenaStartPageView::LayoutData AthenaStartPageView::CreateBottomBounds(
+    int width) {
+  LayoutData state;
+  state.icons.set_size(app_icon_container_->size());
+  state.icons.set_x(kIconMargin);
+  state.icons.set_y(kIconMargin);
+
+  state.controls.set_size(control_icon_container_->size());
+  state.controls.set_x(width - kIconMargin - state.controls.width());
+  state.controls.set_y(kIconMargin);
+
+  state.search_box.set_size(search_box_container_->size());
+  state.search_box.set_x((width - state.search_box.width()) / 2);
+  state.search_box.set_y(
+      (kPreferredHeightBottom - state.search_box.height()) / 2);
+
+  state.logo_opacity = 0.0f;
+  state.background_opacity = 0.9f;
+  return state;
+}
+
+AthenaStartPageView::LayoutData AthenaStartPageView::CreateCenteredBounds(
+    int width) {
+  LayoutData state;
+
+  state.search_box.set_size(search_box_container_->size());
+  state.search_box.set_x((width - state.search_box.width()) / 2);
+  state.search_box.set_y(logo_->bounds().bottom() + kInstantContainerSpacing);
+
+  state.icons.set_size(app_icon_container_->size());
+  state.icons.set_x(width / 2 - state.icons.width() - kIconMargin / 2);
+  state.icons.set_y(state.search_box.bottom() + kInstantContainerSpacing);
+
+  state.controls.set_size(control_icon_container_->size());
+  state.controls.set_x(width / 2 + kIconMargin / 2 + kIconMargin % 2);
+  state.controls.set_y(state.icons.y());
+
+  state.logo_opacity = 1.0f;
+  state.background_opacity = 1.0f;
+  return state;
+}
+
 void AthenaStartPageView::LayoutSearchResults(bool should_show_search_results) {
   if (should_show_search_results ==
       search_results_view_->layer()->GetTargetVisibility()) {
     return;
   }
   if (GetContentsBounds().height() <= kPreferredHeightBottom) {
     search_results_view_->SetVisible(false);
     Layout();
     return;
   }
@@ skipping 49 matching lines @@
   }
 }
 
 void AthenaStartPageView::OnSearchResultLayoutAnimationCompleted(
     bool should_show_search_results) {
   logo_->SetVisible(!should_show_search_results);
   search_results_view_->SetVisible(should_show_search_results);
 }
 
 void AthenaStartPageView::Layout() {
-  gfx::Rect bounds = GetContentsBounds();
   search_results_view_->SetVisible(false);
+  gfx::Rect logo_bounds(x() + width() / 2 - kWebViewWidth / 2, y() + kTopMargin,
+                        kWebViewWidth, kWebViewHeight);
+  logo_->SetBoundsRect(logo_bounds);
 
-  if (bounds.height() <= kPreferredHeightBottom) {
-    logo_->SetVisible(false);
-    gfx::Rect icon_bounds(app_icon_container_->GetPreferredSize());
-    icon_bounds.set_x(bounds.x() + kIconMargin);
-    icon_bounds.set_y(bounds.x() + kIconMargin);
-    app_icon_container_->SetBoundsRect(icon_bounds);
+  LayoutData bottom_bounds = CreateBottomBounds(width());
+  LayoutData centered_bounds = CreateCenteredBounds(width());
 
-    gfx::Rect control_bounds(control_icon_container_->GetPreferredSize());
-    control_bounds.set_x(
-        bounds.right() - kIconMargin - control_bounds.width());
-    control_bounds.set_y(bounds.y() + kIconMargin);
-    control_icon_container_->SetBoundsRect(control_bounds);
+  logo_->layer()->SetOpacity(gfx::Tween::FloatValueBetween(
+      gfx::Tween::CalculateValue(gfx::Tween::EASE_IN_2, layout_state_),
+      bottom_bounds.logo_opacity, centered_bounds.logo_opacity));
+  logo_->SetVisible(logo_->layer()->GetTargetOpacity() != 0.0f);
 
-    search_box_container_->SetBounds(
-        icon_bounds.right(), bounds.y(),
-        control_bounds.x() - icon_bounds.right(), kPreferredHeightBottom);
+  app_icon_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
+      layout_state_, bottom_bounds.icons, centered_bounds.icons));
+  control_icon_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
+      layout_state_, bottom_bounds.controls, centered_bounds.controls));
+  search_box_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
+      layout_state_, bottom_bounds.search_box, centered_bounds.search_box));
 
-    set_background(views::Background::CreateSolidBackground(
-        255, 255, 255, 255 * 0.9));
-  } else {
-    // TODO(mukai): set the intermediate state.
-    logo_->SetVisible(true);
-    logo_->layer()->SetOpacity(1.0f);
-    set_background(views::Background::CreateSolidBackground(SK_ColorWHITE));
-    gfx::Rect logo_bounds(bounds.x() + bounds.width() / 2 - kWebViewWidth / 2,
-                          bounds.y() + kTopMargin,
-                          kWebViewWidth,
-                          kWebViewHeight);
-    logo_->SetBoundsRect(logo_bounds);
-
-    gfx::Rect search_box_bounds(search_box_container_->GetPreferredSize());
-    search_box_bounds.set_x(
-        bounds.x() + bounds.width() / 2 - search_box_bounds.width() / 2);
-    search_box_bounds.set_y(logo_bounds.bottom() + kInstantContainerSpacing);
-    search_box_container_->SetBoundsRect(search_box_bounds);
-
-    gfx::Rect icon_bounds(app_icon_container_->GetPreferredSize());
-    icon_bounds.set_x(bounds.x() + bounds.width() / 2 -
-                      icon_bounds.width() - kIconMargin / 2);
-    icon_bounds.set_y(search_box_bounds.bottom() + kInstantContainerSpacing);
-    app_icon_container_->SetBoundsRect(icon_bounds);
-
-    gfx::Rect control_bounds(control_icon_container_->GetPreferredSize());
-    control_bounds.set_x(bounds.x() + bounds.width() / 2 +
-                         kIconMargin / 2 + kIconMargin % 2);
-    control_bounds.set_y(icon_bounds.y());
-    control_icon_container_->SetBoundsRect(control_bounds);
-  }
+  background_->SetBoundsRect(bounds());
+  background_->layer()->SetOpacity(gfx::Tween::FloatValueBetween(
+      layout_state_,
+      bottom_bounds.background_opacity,
+      centered_bounds.background_opacity));
 }
 
 bool AthenaStartPageView::OnKeyPressed(const ui::KeyEvent& key_event) {
   return search_results_view_->visible() &&
       search_results_view_->OnKeyPressed(key_event);
 }
 
 void AthenaStartPageView::QueryChanged(app_list::SearchBoxView* sender) {
   delegate_->StartSearch();
 
   base::string16 query;
   base::TrimWhitespace(
       delegate_->GetModel()->search_box()->text(), base::TRIM_ALL, &query);
 
   if (!query.empty())
     search_results_view_->SetSelectedIndex(0);
 
   LayoutSearchResults(!query.empty());
 }
 
 }  // namespace athena