app_list: Add sync animation.

ui/app_list/apps_grid_view.cc

 // Copyright (c) 2012 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 "ui/app_list/apps_grid_view.h"
 
 #include <algorithm>
 
 #include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/app_list_item_view.h"
 #include "ui/app_list/apps_grid_view_delegate.h"
 #include "ui/app_list/page_switcher.h"
 #include "ui/app_list/pagination_model.h"
+#include "ui/app_list/pulsing_block_view.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/events/event.h"
 #include "ui/views/border.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // Padding space in pixels for fixed layout.
 const int kLeftRightPadding = 20;
@@ skipping 78 matching lines @@
       drag_view_(NULL),
       drag_pointer_(NONE),
       page_flip_target_(-1),
       page_flip_delay_in_ms_(kPageFlipDelayInMs),
       ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)) {
   pagination_model_->AddObserver(this);
   AddChildView(page_switcher_view_);
 }
 
 AppsGridView::~AppsGridView() {
-  if (model_)
+  if (model_) {
     model_->RemoveObserver(this);
+    model_->apps()->RemoveObserver(this);
+  }
   pagination_model_->RemoveObserver(this);
 }
 
 void AppsGridView::SetLayout(int icon_size, int cols, int rows_per_page) {
   icon_size_.SetSize(icon_size, icon_size);
   cols_ = cols;
   rows_per_page_ = rows_per_page;
 
   set_border(views::Border::CreateEmptyBorder(kTopPadding,
                                               kLeftRightPadding,
                                               0,
                                               kLeftRightPadding));
 }
 
-void AppsGridView::SetModel(AppListModel::Apps* model) {
-  if (model_)
+void AppsGridView::SetModel(AppListModel* model) {
+  if (model_) {
     model_->RemoveObserver(this);
+    model_->apps()->RemoveObserver(this);
+  }
 
   model_ = model;
-  if (model_)
+  if (model_) {
     model_->AddObserver(this);
+    model_->apps()->AddObserver(this);
+  }
   Update();
 }
 
 void AppsGridView::SetSelectedView(views::View* view) {
   if (IsSelectedView(view) || IsDraggedView(view))
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     SetSelectedItemByIndex(index);
@@ skipping 13 matching lines @@
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     pagination_model_->SelectPage(index.page, false);
 }
 
 void AppsGridView::InitiateDrag(views::View* view,
                                 Pointer pointer,
                                 const ui::LocatedEvent& event) {
-  if (drag_view_)
+  if (drag_view_ || pulsing_blocks_model_.view_size())
     return;
 
   drag_view_ = view;
   drag_start_ = event.location();
 }
 
 void AppsGridView::UpdateDrag(views::View* view,
                               Pointer pointer,
                               const ui::LocatedEvent& event) {
   if (!dragging() && drag_view_ &&
@@ skipping 57 matching lines @@
 void AppsGridView::Layout() {
   if (bounds_animator_.IsAnimating())
     bounds_animator_.Cancel();
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
     views::View* view = view_model_.view_at(i);
     if (view != drag_view_)
       view->SetBoundsRect(view_model_.ideal_bounds(i));
   }
+  views::ViewModelUtils::SetViewBoundsToIdealBounds(pulsing_blocks_model_);
 
   const int page_switcher_height =
       page_switcher_view_->GetPreferredSize().height();
   gfx::Rect rect(GetContentsBounds());
   rect.set_y(rect.bottom() - page_switcher_height);
   rect.set_height(page_switcher_height);
   page_switcher_view_->SetBoundsRect(rect);
 }
 
 bool AppsGridView::OnKeyPressed(const ui::KeyEvent& event) {
@@ skipping 49 matching lines @@
     if (drag_view_ == child)
       EndDrag(true);
 
     bounds_animator_.StopAnimatingView(child);
   }
 }
 
 void AppsGridView::Update() {
   selected_view_ = NULL;
   view_model_.Clear();
-  if (model_ && model_->item_count())
-    ListItemsAdded(0, model_->item_count());
+  if (model_ && model_->apps()->item_count())
+    ListItemsAdded(0, model_->apps()->item_count());
 }
 
 void AppsGridView::UpdatePaging() {
   if (!view_model_.view_size() || !tiles_per_page()) {
     pagination_model_->SetTotalPages(0);
     return;
   }
 
   pagination_model_->SetTotalPages(
       (view_model_.view_size() - 1) / tiles_per_page() + 1);
 }
 
+void AppsGridView::UpdatePulsingBlockViews() {
+  const int available_slots =
+      tiles_per_page() - model_->apps()->item_count() % tiles_per_page();
+  const int desired = model_->status() == AppListModel::STATUS_SYNCING ?
+      available_slots : 0;
+
+  if (pulsing_blocks_model_.view_size() == desired)
+    return;
+
+  while (pulsing_blocks_model_.view_size() > desired) {
+    views::View* view = pulsing_blocks_model_.view_at(0);
+    pulsing_blocks_model_.Remove(0);
+    delete view;
+  }
+
+  while (pulsing_blocks_model_.view_size() < desired) {
+    views::View* view = new PulsingBlockView(
+        gfx::Size(kPreferredTileWidth, kPreferredTileHeight), true);
+    pulsing_blocks_model_.Add(view, 0);
+    AddChildView(view);
+  }
+}
+
 views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
-  DCHECK_LT(index, model_->item_count());
+  DCHECK_LT(index, model_->apps()->item_count());
   AppListItemView* view = new AppListItemView(this,
-                                              model_->GetItemAt(index));
+                                              model_->apps()->GetItemAt(index));
   view->SetIconSize(icon_size_);
 #if !defined(OS_WIN)
   view->SetPaintToLayer(true);
   view->SetFillsBoundsOpaquely(false);
 #endif
   return view;
 }
 
 void AppsGridView::SetSelectedItemByIndex(const Index& index) {
   if (GetIndexOfView(selected_view_) == index)
@@ skipping 74 matching lines @@
   const PaginationModel::Transition& transition =
       pagination_model_->transition();
   const bool is_valid =
       pagination_model_->is_valid_page(transition.target_page);
 
   // Transition to right means negative offset.
   const int dir = transition.target_page > current_page ? -1 : 1;
   const int transition_offset = is_valid ?
       transition.progress * page_width * dir : 0;
 
+  const int total_views =
+      view_model_.view_size() + pulsing_blocks_model_.view_size();
   int slot_index = 0;
-  for (int i = 0; i < view_model_.view_size(); ++i) {
-    if (view_model_.view_at(i) == drag_view_)
+  for (int i = 0; i < total_views; ++i) {
+    if (i < view_model_.view_size() && view_model_.view_at(i) == drag_view_)
       continue;
 
     int page = slot_index / tiles_per_page();
     int slot = slot_index % tiles_per_page();
 
     if (drop_target_.page == page && drop_target_.slot == slot) {
       ++slot_index;
       page = slot_index / tiles_per_page();
       slot = slot_index % tiles_per_page();
     }
 
     // Decides an x_offset for current item.
     int x_offset = 0;
     if (page < current_page)
       x_offset = -page_width;
     else if (page > current_page)
       x_offset = page_width;
 
     if (is_valid) {
       if (page == current_page || page == transition.target_page)
         x_offset += transition_offset;
     }
 
     const int row = slot / cols_;
     const int col = slot % cols_;
     gfx::Rect tile_slot(
         gfx::Point(grid_rect.x() + col * tile_size.width() + x_offset,
                    grid_rect.y() + row * tile_size.height()),
         tile_size);
-    view_model_.set_ideal_bounds(i, tile_slot);
+    if (i < view_model_.view_size()) {
+      view_model_.set_ideal_bounds(i, tile_slot);
+    } else {
+      pulsing_blocks_model_.set_ideal_bounds(i - view_model_.view_size(),
+                                             tile_slot);
+    }
 
     ++slot_index;
   }
 }
 
 void AppsGridView::AnimateToIdealBounds() {
   const gfx::Rect visible_bounds(GetVisibleBounds());
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
@@ skipping 142 matching lines @@
 
 void AppsGridView::MoveItemInModel(views::View* item_view,
                                    const Index& target) {
   int current_model_index = view_model_.GetIndexOfView(item_view);
   DCHECK_GE(current_model_index, 0);
 
   int target_model_index = target.page * tiles_per_page() + target.slot;
   if (target_model_index == current_model_index)
     return;
 
-  model_->RemoveObserver(this);
-  model_->Move(current_model_index, target_model_index);
+  model_->apps()->RemoveObserver(this);
+  model_->apps()->Move(current_model_index, target_model_index);
   view_model_.Move(current_model_index, target_model_index);
-  model_->AddObserver(this);
+  model_->apps()->AddObserver(this);
 
   if (pagination_model_->selected_page() != target.page)
     pagination_model_->SelectPage(target.page, false);
 }
 
 void AppsGridView::ButtonPressed(views::Button* sender,
                                  const ui::Event& event) {
   if (dragging())
     return;
 
   if (sender->GetClassName() != AppListItemView::kViewClassName)
     return;
 
   if (delegate_) {
     delegate_->ActivateApp(static_cast<AppListItemView*>(sender)->model(),
                            event.flags());
   }
 }
 
 void AppsGridView::ListItemsAdded(size_t start, size_t count) {
   EndDrag(true);
 
   for (size_t i = start; i < start + count; ++i) {
     views::View* view = CreateViewForItemAtIndex(i);
     view_model_.Add(view, i);
     AddChildView(view);
   }
 
   UpdatePaging();
+  UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::ListItemsRemoved(size_t start, size_t count) {
   EndDrag(true);
 
   for (size_t i = 0; i < count; ++i) {
     views::View* view = view_model_.view_at(start);
     view_model_.Remove(start);
     delete view;
   }
 
   UpdatePaging();
+  UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::ListItemMoved(size_t index, size_t target_index) {
   EndDrag(true);
   view_model_.Move(index, target_index);
 
   UpdatePaging();
   AnimateToIdealBounds();
@@ skipping 18 matching lines @@
 
 void AppsGridView::TransitionChanged() {
   // Update layout for valid page transition only since over-scroll no longer
   // animates app icons.
   const PaginationModel::Transition& transition =
       pagination_model_->transition();
   if (pagination_model_->is_valid_page(transition.target_page))
     Layout();
 }
 
+void AppsGridView::OnAppListModelStatusChanged() {
+  UpdatePulsingBlockViews();
+  Layout();
+  SchedulePaint();
+}
+
 }  // namespace app_list