src/athena/home/athena_start_page_view.cc

   1 // Copyright 2014 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.
   4
   5 #include "athena/home/athena_start_page_view.h"
   6
   7 #include "athena/home/home_card_constants.h"
   8 #include "athena/system/public/system_ui.h"
   9 #include "base/bind.h"
  10 #include "base/strings/string_util.h"
  11 #include "third_party/skia/include/core/SkPaint.h"
  12 #include "third_party/skia/include/core/SkPath.h"
  13 #include "ui/app_list/app_list_item.h"
  14 #include "ui/app_list/app_list_item_list.h"
  15 #include "ui/app_list/app_list_model.h"
  16 #include "ui/app_list/app_list_view_delegate.h"
  17 #include "ui/app_list/search_box_model.h"
  18 #include "ui/app_list/views/search_box_view.h"
  19 #include "ui/app_list/views/search_result_list_view.h"
  20 #include "ui/compositor/closure_animation_observer.h"
  21 #include "ui/compositor/scoped_layer_animation_settings.h"
  22 #include "ui/gfx/canvas.h"
  23 #include "ui/views/background.h"
  24 #include "ui/views/border.h"
  25 #include "ui/views/controls/textfield/textfield.h"
  26 #include "ui/views/layout/box_layout.h"
  27 #include "ui/views/layout/fill_layout.h"
  28 #include "ui/views/round_rect_painter.h"
  29
  30 namespace {
  31
  32 const size_t kMaxIconNum = 3;
  33 const int kIconSize = 50;
  34 const int kIconMargin = 25;
  35
  36 const int kTopMargin = 100;
  37
  38 // Copied from ui/app_list/views/start_page_view.cc
  39 const int kInstantContainerSpacing = 20;
  40 const int kWebViewWidth = 500;
  41 const int kWebViewHeight = 105;
  42 const int kSearchBoxBorderWidth = 1;
  43 const int kSearchBoxCornerRadius = 2;
  44
  45 // Taken from the mock. The width is not specified by pixel but the search box
  46 // covers 6 icons with margin.
  47 const int kSearchBoxWidth = kIconSize * 6 + kIconMargin * 7;
  48 const int kSearchBoxHeight = 40;
  49
  50 gfx::Size GetIconContainerSize() {
  51   return gfx::Size(kIconSize *  kMaxIconNum + kIconMargin * (kMaxIconNum - 1),
  52                    kIconSize);
  53 }
  54
  55 class PlaceHolderButton : public views::ImageButton,
  56                           public views::ButtonListener {
  57  public:
  58   PlaceHolderButton()
  59       : ImageButton(this) {
  60     gfx::Canvas canvas(gfx::Size(kIconSize, kIconSize), 1.0f, true);
  61     SkPaint paint;
  62     paint.setStyle(SkPaint::kFill_Style);
  63     paint.setColor(SkColorSetRGB(86, 119, 252));
  64     paint.setFlags(SkPaint::kAntiAlias_Flag);
  65     canvas.DrawCircle(
  66         gfx::Point(kIconSize / 2, kIconSize / 2), kIconSize / 2, paint);
  67
  68     scoped_ptr<gfx::ImageSkia> image(
  69         new gfx::ImageSkia(canvas.ExtractImageRep()));
  70     SetImage(STATE_NORMAL, image.get());
  71   }
  72
  73  private:
  74   // views::ButtonListener:
  75   virtual void ButtonPressed(views::Button* sender,
  76                              const ui::Event& event) OVERRIDE {
  77     // Do nothing: remove these place holders.
  78   }
  79
  80   DISALLOW_COPY_AND_ASSIGN(PlaceHolderButton);
  81 };
  82
  83 class AppIconButton : public views::ImageButton,
  84                       public views::ButtonListener {
  85  public:
  86   explicit AppIconButton(app_list::AppListItem* item)
  87       : ImageButton(this),
  88         item_(item) {
  89     // TODO(mukai): icon should be resized.
  90     SetImage(STATE_NORMAL, &item->icon());
  91   }
  92
  93  private:
  94   // views::ButtonListener:
  95   virtual void ButtonPressed(views::Button* sender,
  96                              const ui::Event& event) OVERRIDE {
  97     DCHECK_EQ(sender, this);
  98     item_->Activate(event.flags());
  99   }
 100
 101   app_list::AppListItem* item_;
 102
 103   DISALLOW_COPY_AND_ASSIGN(AppIconButton);
 104 };
 105
 106 // The background to paint the round rectangle of the view area.
 107 class RoundRectBackground : public views::Background {
 108  public:
 109   RoundRectBackground(SkColor color, int corner_radius)
 110       : color_(color),
 111         corner_radius_(corner_radius) {}
 112   virtual ~RoundRectBackground() {}
 113
 114  private:
 115   // views::Background:
 116   virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE {
 117     SkPaint paint;
 118     paint.setStyle(SkPaint::kFill_Style);
 119     paint.setColor(color_);
 120     canvas->DrawRoundRect(view->GetContentsBounds(), corner_radius_, paint);
 121   }
 122
 123   SkColor color_;
 124   int corner_radius_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(RoundRectBackground);
 127 };
 128
 129 class SearchBoxContainer : public views::View {
 130  public:
 131   explicit SearchBoxContainer(app_list::SearchBoxView* search_box)
 132       : search_box_(search_box) {
 133     search_box->set_background(
 134         new RoundRectBackground(SK_ColorWHITE, kSearchBoxCornerRadius));
 135     search_box->SetBorder(views::Border::CreateBorderPainter(
 136         new views::RoundRectPainter(SK_ColorGRAY, kSearchBoxCornerRadius),
 137         gfx::Insets(kSearchBoxBorderWidth, kSearchBoxBorderWidth,
 138                     kSearchBoxBorderWidth, kSearchBoxBorderWidth)));
 139     SetLayoutManager(new views::FillLayout());
 140     AddChildView(search_box_);
 141   }
 142   virtual ~SearchBoxContainer() {}
 143
 144  private:
 145   // views::View:
 146   virtual gfx::Size GetPreferredSize() const OVERRIDE {
 147     return gfx::Size(kSearchBoxWidth, kSearchBoxHeight);
 148   }
 149
 150   // Owned by the views hierarchy.
 151   app_list::SearchBoxView* search_box_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(SearchBoxContainer);
 154 };
 155
 156 }  // namespace
 157
 158 namespace athena {
 159
 160 // static
 161 const char AthenaStartPageView::kViewClassName[] = "AthenaStartPageView";
 162
 163 AthenaStartPageView::LayoutData::LayoutData()
 164     : system_info_opacity(1.0f),
 165       logo_opacity(1.0f),
 166       background_opacity(1.0f) {
 167 }
 168
 169 AthenaStartPageView::AthenaStartPageView(
 170     app_list::AppListViewDelegate* view_delegate)
 171     : delegate_(view_delegate),
 172       layout_state_(0.0f),
 173       weak_factory_(this) {
 174   background_ = new views::View();
 175   background_->set_background(
 176       views::Background::CreateSolidBackground(SK_ColorWHITE));
 177   background_->SetPaintToLayer(true);
 178   background_->SetFillsBoundsOpaquely(false);
 179   AddChildView(background_);
 180
 181   system_info_view_ =
 182       SystemUI::Get()->CreateSystemInfoView(SystemUI::COLOR_SCHEME_DARK);
 183   system_info_view_->SetPaintToLayer(true);
 184   system_info_view_->SetFillsBoundsOpaquely(false);
 185   AddChildView(system_info_view_);
 186
 187   logo_ = view_delegate->CreateStartPageWebView(
 188       gfx::Size(kWebViewWidth, kWebViewHeight));
 189   logo_->SetPaintToLayer(true);
 190   logo_->SetFillsBoundsOpaquely(false);
 191   logo_->SetSize(gfx::Size(kWebViewWidth, kWebViewHeight));
 192   AddChildView(logo_);
 193
 194   search_results_view_ = new app_list::SearchResultListView(
 195       NULL, view_delegate);
 196   // search_results_view_'s size will shrink after settings results.
 197   search_results_height_ = static_cast<views::View*>(
 198       search_results_view_)->GetHeightForWidth(kSearchBoxWidth);
 199   search_results_view_->SetResults(view_delegate->GetModel()->results());
 200
 201   search_results_view_->SetVisible(false);
 202   search_results_view_->SetPaintToLayer(true);
 203   search_results_view_->SetFillsBoundsOpaquely(false);
 204   AddChildView(search_results_view_);
 205
 206   app_icon_container_ = new views::View();
 207   AddChildView(app_icon_container_);
 208   app_icon_container_->SetPaintToLayer(true);
 209   app_icon_container_->layer()->SetFillsBoundsOpaquely(false);
 210   app_icon_container_->SetLayoutManager(new views::BoxLayout(
 211       views::BoxLayout::kHorizontal, 0, 0, kIconMargin));
 212   app_list::AppListItemList* top_level =
 213       view_delegate->GetModel()->top_level_item_list();
 214   for (size_t i = 0; i < std::min(top_level->item_count(), kMaxIconNum); ++i)
 215     app_icon_container_->AddChildView(new AppIconButton(top_level->item_at(i)));
 216   app_icon_container_->SetSize(GetIconContainerSize());
 217
 218   control_icon_container_ = new views::View();
 219   control_icon_container_->SetPaintToLayer(true);
 220   control_icon_container_->SetFillsBoundsOpaquely(false);
 221   AddChildView(control_icon_container_);
 222   control_icon_container_->SetLayoutManager(new views::BoxLayout(
 223       views::BoxLayout::kHorizontal, 0, 0, kIconMargin));
 224   for (size_t i = 0; i < kMaxIconNum; ++i)
 225     control_icon_container_->AddChildView(new PlaceHolderButton());
 226   control_icon_container_->SetSize(GetIconContainerSize());
 227
 228   search_box_view_ = new app_list::SearchBoxView(this, view_delegate);
 229   search_box_view_->set_contents_view(this);
 230   search_box_view_->search_box()->set_id(kHomeCardSearchBoxId);
 231   search_box_container_ = new SearchBoxContainer(search_box_view_);
 232   search_box_container_->SetPaintToLayer(true);
 233   search_box_container_->SetFillsBoundsOpaquely(false);
 234   search_box_container_->SetSize(search_box_container_->GetPreferredSize());
 235   AddChildView(search_box_container_);
 236 }
 237
 238 AthenaStartPageView::~AthenaStartPageView() {}
 239
 240 void AthenaStartPageView::RequestFocusOnSearchBox() {
 241   search_box_view_->search_box()->RequestFocus();
 242 }
 243
 244 void AthenaStartPageView::SetLayoutState(float layout_state) {
 245   layout_state_ = layout_state;
 246   Layout();
 247 }
 248
 249 void AthenaStartPageView::SetLayoutStateWithAnimation(
 250     float layout_state,
 251     gfx::Tween::Type tween_type) {
 252   ui::ScopedLayerAnimationSettings system_info(
 253       system_info_view_->layer()->GetAnimator());
 254   ui::ScopedLayerAnimationSettings logo(logo_->layer()->GetAnimator());
 255   ui::ScopedLayerAnimationSettings search_box(
 256       search_box_container_->layer()->GetAnimator());
 257   ui::ScopedLayerAnimationSettings icons(
 258       app_icon_container_->layer()->GetAnimator());
 259   ui::ScopedLayerAnimationSettings controls(
 260       control_icon_container_->layer()->GetAnimator());
 261
 262   system_info.SetTweenType(tween_type);
 263   logo.SetTweenType(tween_type);
 264   search_box.SetTweenType(tween_type);
 265   icons.SetTweenType(tween_type);
 266   controls.SetTweenType(tween_type);
 267
 268   SetLayoutState(layout_state);
 269 }
 270
 271 AthenaStartPageView::LayoutData AthenaStartPageView::CreateBottomBounds(
 272     int width) {
 273   LayoutData state;
 274   state.icons.set_size(app_icon_container_->size());
 275   state.icons.set_x(kIconMargin);
 276   state.icons.set_y(kIconMargin);
 277
 278   state.controls.set_size(control_icon_container_->size());
 279   state.controls.set_x(width - kIconMargin - state.controls.width());
 280   state.controls.set_y(kIconMargin);
 281
 282   int search_box_max_width =
 283       state.controls.x() - state.icons.right() - kIconMargin * 2;
 284   state.search_box.set_width(std::min(search_box_max_width, kSearchBoxWidth));
 285   state.search_box.set_height(search_box_container_->height());
 286   state.search_box.set_x((width - state.search_box.width()) / 2);
 287   state.search_box.set_y((kHomeCardHeight - state.search_box.height()) / 2);
 288
 289   state.system_info_opacity = 0.0f;
 290   state.logo_opacity = 0.0f;
 291   state.background_opacity = 0.9f;
 292   return state;
 293 }
 294
 295 AthenaStartPageView::LayoutData AthenaStartPageView::CreateCenteredBounds(
 296     int width) {
 297   LayoutData state;
 298
 299   state.search_box.set_size(search_box_container_->GetPreferredSize());
 300   state.search_box.set_x((width - state.search_box.width()) / 2);
 301   state.search_box.set_y(logo_->bounds().bottom() + kInstantContainerSpacing);
 302
 303   state.icons.set_size(app_icon_container_->size());
 304   state.icons.set_x(width / 2 - state.icons.width() - kIconMargin / 2);
 305   state.icons.set_y(state.search_box.bottom() + kInstantContainerSpacing);
 306
 307   state.controls.set_size(control_icon_container_->size());
 308   state.controls.set_x(width / 2 + kIconMargin / 2 + kIconMargin % 2);
 309   state.controls.set_y(state.icons.y());
 310
 311   state.system_info_opacity = 1.0f;
 312   state.logo_opacity = 1.0f;
 313   state.background_opacity = 1.0f;
 314   return state;
 315 }
 316
 317 void AthenaStartPageView::LayoutSearchResults(bool should_show_search_results) {
 318   if (should_show_search_results ==
 319       search_results_view_->layer()->GetTargetVisibility()) {
 320     return;
 321   }
 322   if (GetContentsBounds().height() <= kHomeCardHeight) {
 323     search_results_view_->SetVisible(false);
 324     Layout();
 325     return;
 326   }
 327
 328   gfx::Rect search_box_bounds = search_box_container_->bounds();
 329   if (!search_results_view_->visible()) {
 330     search_results_view_->SetVisible(true);
 331     search_results_view_->SetBounds(
 332         search_box_bounds.x(), search_box_bounds.bottom(),
 333         search_box_bounds.width(), 0);
 334   }
 335   logo_->SetVisible(true);
 336
 337   {
 338     ui::ScopedLayerAnimationSettings logo_settings(
 339         logo_->layer()->GetAnimator());
 340     logo_settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
 341     logo_settings.AddObserver(new ui::ClosureAnimationObserver(
 342         base::Bind(&AthenaStartPageView::OnSearchResultLayoutAnimationCompleted,
 343                    weak_factory_.GetWeakPtr(),
 344                    should_show_search_results)));
 345
 346     ui::ScopedLayerAnimationSettings search_box_settings(
 347         search_box_container_->layer()->GetAnimator());
 348     search_box_settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
 349
 350     ui::ScopedLayerAnimationSettings search_results_settings(
 351         search_results_view_->layer()->GetAnimator());
 352     search_results_settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
 353
 354     if (should_show_search_results) {
 355       logo_->layer()->SetOpacity(0.0f);
 356       search_box_bounds.set_y(
 357           search_box_bounds.y() - search_results_height_ -
 358           kInstantContainerSpacing);
 359       search_box_container_->SetBoundsRect(search_box_bounds);
 360       search_results_view_->SetBounds(
 361           search_box_bounds.x(),
 362           search_box_bounds.bottom() + kInstantContainerSpacing,
 363           search_box_bounds.width(),
 364           search_results_height_);
 365     } else {
 366       logo_->layer()->SetOpacity(1.0f);
 367       search_box_bounds.set_y(
 368           logo_->bounds().bottom() + kInstantContainerSpacing);
 369       search_box_container_->SetBoundsRect(search_box_bounds);
 370
 371       gfx::Rect search_results_bounds = search_results_view_->bounds();
 372       search_results_bounds.set_y(search_results_bounds.bottom());
 373       search_results_bounds.set_height(0);
 374       search_results_view_->SetBoundsRect(search_results_bounds);
 375     }
 376   }
 377 }
 378
 379 void AthenaStartPageView::OnSearchResultLayoutAnimationCompleted(
 380     bool should_show_search_results) {
 381   logo_->SetVisible(!should_show_search_results);
 382   search_results_view_->SetVisible(should_show_search_results);
 383 }
 384
 385 void AthenaStartPageView::Layout() {
 386   search_results_view_->SetVisible(false);
 387
 388   system_info_view_->SetBounds(
 389       0, 0, width(), system_info_view_->GetPreferredSize().height());
 390
 391   gfx::Rect logo_bounds(x() + width() / 2 - kWebViewWidth / 2, y() + kTopMargin,
 392                         kWebViewWidth, kWebViewHeight);
 393   logo_->SetBoundsRect(logo_bounds);
 394
 395   LayoutData bottom_bounds = CreateBottomBounds(width());
 396   LayoutData centered_bounds = CreateCenteredBounds(width());
 397
 398   system_info_view_->layer()->SetOpacity(gfx::Tween::FloatValueBetween(
 399       gfx::Tween::CalculateValue(gfx::Tween::EASE_IN_2, layout_state_),
 400       bottom_bounds.system_info_opacity, centered_bounds.system_info_opacity));
 401   system_info_view_->SetVisible(
 402       system_info_view_->layer()->GetTargetOpacity() != 0.0f);
 403
 404   logo_->layer()->SetOpacity(gfx::Tween::FloatValueBetween(
 405       gfx::Tween::CalculateValue(gfx::Tween::EASE_IN_2, layout_state_),
 406       bottom_bounds.logo_opacity, centered_bounds.logo_opacity));
 407   logo_->SetVisible(logo_->layer()->GetTargetOpacity() != 0.0f);
 408
 409   app_icon_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
 410       layout_state_, bottom_bounds.icons, centered_bounds.icons));
 411   control_icon_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
 412       layout_state_, bottom_bounds.controls, centered_bounds.controls));
 413   search_box_container_->SetBoundsRect(gfx::Tween::RectValueBetween(
 414       layout_state_, bottom_bounds.search_box, centered_bounds.search_box));
 415
 416   background_->SetBoundsRect(bounds());
 417   background_->layer()->SetOpacity(gfx::Tween::FloatValueBetween(
 418       layout_state_,
 419       bottom_bounds.background_opacity,
 420       centered_bounds.background_opacity));
 421 }
 422
 423 bool AthenaStartPageView::OnKeyPressed(const ui::KeyEvent& key_event) {
 424   return search_results_view_->visible() &&
 425       search_results_view_->OnKeyPressed(key_event);
 426 }
 427
 428 void AthenaStartPageView::QueryChanged(app_list::SearchBoxView* sender) {
 429   delegate_->StartSearch();
 430
 431   base::string16 query;
 432   base::TrimWhitespace(
 433       delegate_->GetModel()->search_box()->text(), base::TRIM_ALL, &query);
 434
 435   if (!query.empty())
 436     search_results_view_->SetSelectedIndex(0);
 437
 438   LayoutSearchResults(!query.empty());
 439 }
 440
 441 }  // namespace athena