[Athena] Add status icons and system time to the centered home card

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 "athena/home/home_card_constants.h"
+#include "athena/system/public/system_ui.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"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_item_list.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/app_list_view_delegate.h"
 #include "ui/app_list/search_box_model.h"
 #include "ui/app_list/views/search_box_view.h"
@@ skipping 130 matching lines @@
 };
 
 }  // namespace
 
 namespace athena {
 
 // static
 const char AthenaStartPageView::kViewClassName[] = "AthenaStartPageView";
 
 AthenaStartPageView::LayoutData::LayoutData()
-    : logo_opacity(1.0f),
+    : top_view_opacity(1.0f),
+      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_);
 
+  time_view_ = SystemUI::Get()->CreateTimeView(SystemUI::COLOR_SCHEME_DARK);
+  time_view_->SetPaintToLayer(true);
+  // Set a background on the view because painting text on a transparent layer
+  // looks bad. |time_view_|'s background animating at a different rate than

[sadrul, 2014/09/02 15:11:14]

I think you can set some attrib on the Label so the text looks OK on a
transparent layer (iirc we use it for the ash-tray texts).

[pkotwicz, 2014/09/02 19:47:49]

Disabling subpixel rendering does the trick. Thanks for making me look.

+  // |background_| is not noticeable in practice.
+  time_view_->set_background(
+      views::Background::CreateSolidBackground(SK_ColorWHITE));
+  AddChildView(time_view_);
+
+  status_icon_view_ =
+      SystemUI::Get()->CreateStatusIconView(SystemUI::COLOR_SCHEME_DARK);
+  status_icon_view_->set_background(
+      views::Background::CreateSolidBackground(SK_ColorWHITE));
+  status_icon_view_->SetPaintToLayer(true);
+  AddChildView(status_icon_view_);
+
   logo_ = view_delegate->CreateStartPageWebView(
       gfx::Size(kWebViewWidth, kWebViewHeight));
   logo_->SetPaintToLayer(true);
   logo_->SetFillsBoundsOpaquely(false);
   logo_->SetSize(gfx::Size(kWebViewWidth, kWebViewHeight));
   AddChildView(logo_);
 
   search_results_view_ = new app_list::SearchResultListView(
       NULL, view_delegate);
   // search_results_view_'s size will shrink after settings results.
@@ skipping 43 matching lines @@
 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 time(
+      time_view_->layer()->GetAnimator());
+  ui::ScopedLayerAnimationSettings status_icon(
+      status_icon_view_->layer()->GetAnimator());
   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());
 
+  time.SetTweenType(gfx::Tween::EASE_IN_OUT);
+  status_icon.SetTweenType(gfx::Tween::EASE_IN_OUT);
   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);
 
   int search_box_max_width =
       state.controls.x() - state.icons.right() - kIconMargin * 2;
   state.search_box.set_width(std::min(search_box_max_width, kSearchBoxWidth));
   state.search_box.set_height(search_box_container_->height());
   state.search_box.set_x((width - state.search_box.width()) / 2);
   state.search_box.set_y((kHomeCardHeight - state.search_box.height()) / 2);
 
+  state.top_view_opacity = 0.0f;
   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_->GetPreferredSize());
   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.top_view_opacity = 1.0f;
   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;
   }
@@ skipping 55 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() {
   search_results_view_->SetVisible(false);
+
+  // The time goes in the top left corner.
+  time_view_->SetBoundsRect(gfx::Rect(time_view_->GetPreferredSize()));
+
+  // The status icons go in the top right corner.
+  gfx::Size status_icon_view_preferred_size =
+      status_icon_view_->GetPreferredSize();
+  status_icon_view_->SetBoundsRect(
+      gfx::Rect(width() - status_icon_view_preferred_size.width(),
+                0,
+                status_icon_view_preferred_size.width(),
+                status_icon_view_preferred_size.height()));
+
   gfx::Rect logo_bounds(x() + width() / 2 - kWebViewWidth / 2, y() + kTopMargin,
                         kWebViewWidth, kWebViewHeight);
   logo_->SetBoundsRect(logo_bounds);
 
   LayoutData bottom_bounds = CreateBottomBounds(width());
   LayoutData centered_bounds = CreateCenteredBounds(width());
 
+  float top_view_opacity = gfx::Tween::FloatValueBetween(
+      gfx::Tween::CalculateValue(gfx::Tween::EASE_IN_2, layout_state_),
+      bottom_bounds.top_view_opacity, centered_bounds.top_view_opacity);
+  time_view_->layer()->SetOpacity(top_view_opacity);
+  time_view_->SetVisible(time_view_->layer()->GetTargetOpacity() != 0.0f);
+  status_icon_view_->layer()->SetOpacity(top_view_opacity);
+  status_icon_view_->SetVisible(
+      status_icon_view_->layer()->GetTargetOpacity() != 0.0f);
+
   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);
 
   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));
 
   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::ChildPreferredSizeChanged(views::View* view) {
+  // Relayout when |status_icon_view_| changes its preferred size.
+  Layout();
+}
+
 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