ui/app_list/views/contents_view.cc

   1 // Copyright (c) 2012 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 "ui/app_list/views/contents_view.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "grit/ui_resources.h"
  11 #include "ui/app_list/app_list_constants.h"
  12 #include "ui/app_list/app_list_switches.h"
  13 #include "ui/app_list/app_list_view_delegate.h"
  14 #include "ui/app_list/views/app_list_folder_view.h"
  15 #include "ui/app_list/views/app_list_main_view.h"
  16 #include "ui/app_list/views/apps_container_view.h"
  17 #include "ui/app_list/views/apps_grid_view.h"
  18 #include "ui/app_list/views/contents_switcher_view.h"
  19 #include "ui/app_list/views/search_result_list_view.h"
  20 #include "ui/app_list/views/start_page_view.h"
  21 #include "ui/base/resource/resource_bundle.h"
  22 #include "ui/events/event.h"
  23 #include "ui/views/view_model.h"
  24 #include "ui/views/view_model_utils.h"
  25
  26 namespace app_list {
  27
  28 namespace {
  29
  30 const int kMinMouseWheelToSwitchPage = 20;
  31 const int kMinScrollToSwitchPage = 20;
  32 const int kMinHorizVelocityToSwitchPage = 800;
  33
  34 const double kFinishTransitionThreshold = 0.33;
  35
  36 }  // namespace
  37
  38 ContentsView::ContentsView(AppListMainView* app_list_main_view)
  39     : search_results_view_(NULL),
  40       start_page_view_(NULL),
  41       app_list_main_view_(app_list_main_view),
  42       contents_switcher_view_(NULL),
  43       view_model_(new views::ViewModel) {
  44   pagination_model_.AddObserver(this);
  45 }
  46
  47 ContentsView::~ContentsView() {
  48   pagination_model_.RemoveObserver(this);
  49 }
  50
  51 void ContentsView::InitNamedPages(AppListModel* model,
  52                                   AppListViewDelegate* view_delegate) {
  53   DCHECK(model);
  54
  55   if (app_list::switches::IsExperimentalAppListEnabled()) {
  56     start_page_view_ = new StartPageView(app_list_main_view_, view_delegate);
  57     AddLauncherPage(
  58         start_page_view_, IDR_APP_LIST_SEARCH_ICON, NAMED_PAGE_START);
  59   } else {
  60     search_results_view_ =
  61         new SearchResultListView(app_list_main_view_, view_delegate);
  62     AddLauncherPage(search_results_view_, 0, NAMED_PAGE_SEARCH_RESULTS);
  63     search_results_view_->SetResults(model->results());
  64   }
  65
  66   apps_container_view_ = new AppsContainerView(app_list_main_view_, model);
  67   int apps_page_index = AddLauncherPage(
  68       apps_container_view_, IDR_APP_LIST_APPS_ICON, NAMED_PAGE_APPS);
  69
  70   pagination_model_.SelectPage(apps_page_index, false);
  71 }
  72
  73 void ContentsView::CancelDrag() {
  74   if (apps_container_view_->apps_grid_view()->has_dragged_view())
  75     apps_container_view_->apps_grid_view()->EndDrag(true);
  76   if (apps_container_view_->app_list_folder_view()
  77           ->items_grid_view()
  78           ->has_dragged_view()) {
  79     apps_container_view_->app_list_folder_view()->items_grid_view()->EndDrag(
  80         true);
  81   }
  82 }
  83
  84 void ContentsView::SetDragAndDropHostOfCurrentAppList(
  85     ApplicationDragAndDropHost* drag_and_drop_host) {
  86   apps_container_view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
  87 }
  88
  89 void ContentsView::SetActivePage(int page_index) {
  90   if (GetActivePageIndex() == page_index)
  91     return;
  92
  93   SetActivePageInternal(page_index, false);
  94 }
  95
  96 int ContentsView::GetActivePageIndex() const {
  97   // The active page is changed at the beginning of an animation, not the end.
  98   return pagination_model_.SelectedTargetPage();
  99 }
 100
 101 bool ContentsView::IsNamedPageActive(NamedPage named_page) const {
 102   std::map<NamedPage, int>::const_iterator it =
 103       named_page_to_view_.find(named_page);
 104   if (it == named_page_to_view_.end())
 105     return false;
 106   return it->second == GetActivePageIndex();
 107 }
 108
 109 int ContentsView::GetPageIndexForNamedPage(NamedPage named_page) const {
 110   // Find the index of the view corresponding to the given named_page.
 111   std::map<NamedPage, int>::const_iterator it =
 112       named_page_to_view_.find(named_page);
 113   // GetPageIndexForNamedPage should never be called on a named_page that does
 114   // not have a corresponding view.
 115   DCHECK(it != named_page_to_view_.end());
 116   return it->second;
 117 }
 118
 119 int ContentsView::NumLauncherPages() const {
 120   return pagination_model_.total_pages();
 121 }
 122
 123 void ContentsView::SetActivePageInternal(int page_index,
 124                                          bool show_search_results) {
 125   // Start animating to the new page.
 126   pagination_model_.SelectPage(page_index, true);
 127   ActivePageChanged(show_search_results);
 128 }
 129
 130 void ContentsView::ActivePageChanged(bool show_search_results) {
 131   // TODO(xiyuan): Highlight default match instead of the first.
 132   if (IsNamedPageActive(NAMED_PAGE_SEARCH_RESULTS) &&
 133       search_results_view_->visible()) {
 134     search_results_view_->SetSelectedIndex(0);
 135   }
 136   if (search_results_view_)
 137     search_results_view_->UpdateAutoLaunchState();
 138
 139   if (IsNamedPageActive(NAMED_PAGE_START)) {
 140     if (show_search_results)
 141       start_page_view_->ShowSearchResults();
 142     else
 143       start_page_view_->Reset();
 144   }
 145
 146   // Notify parent AppListMainView of the page change.
 147   app_list_main_view_->UpdateSearchBoxVisibility();
 148 }
 149
 150 void ContentsView::ShowSearchResults(bool show) {
 151   NamedPage new_named_page = show ? NAMED_PAGE_SEARCH_RESULTS : NAMED_PAGE_APPS;
 152   if (app_list::switches::IsExperimentalAppListEnabled())
 153     new_named_page = NAMED_PAGE_START;
 154
 155   SetActivePageInternal(GetPageIndexForNamedPage(new_named_page), show);
 156 }
 157
 158 bool ContentsView::IsShowingSearchResults() const {
 159   return app_list::switches::IsExperimentalAppListEnabled()
 160              ? IsNamedPageActive(NAMED_PAGE_START) &&
 161                    start_page_view_->IsShowingSearchResults()
 162              : IsNamedPageActive(NAMED_PAGE_SEARCH_RESULTS);
 163 }
 164
 165 void ContentsView::UpdatePageBounds() {
 166   gfx::Rect rect(GetContentsBounds());
 167   if (rect.IsEmpty())
 168     return;
 169
 170   // The bounds calculations will potentially be mid-transition (depending on
 171   // the state of the PaginationModel).
 172   int current_page = std::max(0, pagination_model_.selected_page());
 173   int target_page = current_page;
 174   double progress = 1;
 175   if (pagination_model_.has_transition()) {
 176     const PaginationModel::Transition& transition =
 177         pagination_model_.transition();
 178     if (pagination_model_.is_valid_page(transition.target_page)) {
 179       target_page = transition.target_page;
 180       progress = transition.progress;
 181     }
 182   }
 183
 184   gfx::Rect incoming_target(rect);
 185   gfx::Rect outgoing_target(rect);
 186   int dir = target_page > current_page ? -1 : 1;
 187
 188   if (app_list::switches::IsExperimentalAppListEnabled()) {
 189     // The experimental app list transitions horizontally.
 190     int page_width = rect.width();
 191     int transition_offset = progress * page_width * dir;
 192
 193     outgoing_target.set_x(transition_offset);
 194     incoming_target.set_x(dir < 0 ? transition_offset + page_width
 195                                   : transition_offset - page_width);
 196   } else {
 197     // The normal app list transitions vertically.
 198     int page_height = rect.height();
 199     int transition_offset = progress * page_height * dir;
 200
 201     outgoing_target.set_y(transition_offset);
 202     incoming_target.set_y(dir < 0 ? transition_offset + page_height
 203                                   : transition_offset - page_height);
 204   }
 205
 206   view_model_->view_at(current_page)->SetBoundsRect(outgoing_target);
 207   view_model_->view_at(target_page)->SetBoundsRect(incoming_target);
 208 }
 209
 210 PaginationModel* ContentsView::GetAppsPaginationModel() {
 211   return apps_container_view_->apps_grid_view()->pagination_model();
 212 }
 213
 214 void ContentsView::ShowFolderContent(AppListFolderItem* item) {
 215   apps_container_view_->ShowActiveFolder(item);
 216 }
 217
 218 void ContentsView::Prerender() {
 219   const int selected_page =
 220       std::max(0, GetAppsPaginationModel()->selected_page());
 221   apps_container_view_->apps_grid_view()->Prerender(selected_page);
 222 }
 223
 224 views::View* ContentsView::GetPageView(int index) {
 225   return view_model_->view_at(index);
 226 }
 227
 228 void ContentsView::AddBlankPageForTesting() {
 229   AddLauncherPage(new views::View, 0);
 230 }
 231
 232 int ContentsView::AddLauncherPage(views::View* view, int resource_id) {
 233   int page_index = view_model_->view_size();
 234   AddChildView(view);
 235   view_model_->Add(view, page_index);
 236   pagination_model_.SetTotalPages(view_model_->view_size());
 237   if (contents_switcher_view_)
 238     contents_switcher_view_->AddSwitcherButton(resource_id, page_index);
 239   return page_index;
 240 }
 241
 242 int ContentsView::AddLauncherPage(views::View* view,
 243                                   int resource_id,
 244                                   NamedPage named_page) {
 245   int page_index = AddLauncherPage(view, resource_id);
 246   named_page_to_view_.insert(std::pair<NamedPage, int>(named_page, page_index));
 247   return page_index;
 248 }
 249
 250 gfx::Size ContentsView::GetPreferredSize() const {
 251   const gfx::Size container_size =
 252       apps_container_view_->apps_grid_view()->GetPreferredSize();
 253   const gfx::Size results_size = search_results_view_
 254                                      ? search_results_view_->GetPreferredSize()
 255                                      : gfx::Size();
 256
 257   int width = std::max(container_size.width(), results_size.width());
 258   int height = std::max(container_size.height(), results_size.height());
 259   return gfx::Size(width, height);
 260 }
 261
 262 void ContentsView::Layout() {
 263   // Immediately finish all current animations.
 264   pagination_model_.FinishAnimation();
 265
 266   // Move the current view onto the screen, and all other views off screen to
 267   // the left. (Since we are not animating, we don't need to be careful about
 268   // which side we place the off-screen views onto.)
 269   gfx::Rect rect(GetContentsBounds());
 270   if (rect.IsEmpty())
 271     return;
 272
 273   gfx::Rect offscreen_target(rect);
 274   offscreen_target.set_x(-rect.width());
 275
 276   for (int i = 0; i < view_model_->view_size(); ++i) {
 277     view_model_->view_at(i)->SetBoundsRect(
 278         i == pagination_model_.SelectedTargetPage() ? rect : offscreen_target);
 279   }
 280 }
 281
 282 bool ContentsView::OnKeyPressed(const ui::KeyEvent& event) {
 283   return view_model_->view_at(GetActivePageIndex())->OnKeyPressed(event);
 284 }
 285
 286 bool ContentsView::OnMouseWheel(const ui::MouseWheelEvent& event) {
 287   if (!IsNamedPageActive(NAMED_PAGE_APPS))
 288     return false;
 289
 290   int offset;
 291   if (abs(event.x_offset()) > abs(event.y_offset()))
 292     offset = event.x_offset();
 293   else
 294     offset = event.y_offset();
 295
 296   if (abs(offset) > kMinMouseWheelToSwitchPage) {
 297     if (!GetAppsPaginationModel()->has_transition()) {
 298       GetAppsPaginationModel()->SelectPageRelative(offset > 0 ? -1 : 1, true);
 299     }
 300     return true;
 301   }
 302
 303   return false;
 304 }
 305
 306 void ContentsView::TotalPagesChanged() {
 307 }
 308
 309 void ContentsView::SelectedPageChanged(int old_selected, int new_selected) {
 310 }
 311
 312 void ContentsView::TransitionStarted() {
 313 }
 314
 315 void ContentsView::TransitionChanged() {
 316   UpdatePageBounds();
 317 }
 318
 319 void ContentsView::OnGestureEvent(ui::GestureEvent* event) {
 320   if (!IsNamedPageActive(NAMED_PAGE_APPS))
 321     return;
 322
 323   switch (event->type()) {
 324     case ui::ET_GESTURE_SCROLL_BEGIN:
 325       GetAppsPaginationModel()->StartScroll();
 326       event->SetHandled();
 327       return;
 328     case ui::ET_GESTURE_SCROLL_UPDATE:
 329       // event->details.scroll_x() > 0 means moving contents to right. That is,
 330       // transitioning to previous page.
 331       GetAppsPaginationModel()->UpdateScroll(event->details().scroll_x() /
 332                                              GetContentsBounds().width());
 333       event->SetHandled();
 334       return;
 335     case ui::ET_GESTURE_SCROLL_END:
 336       GetAppsPaginationModel()->EndScroll(
 337           GetAppsPaginationModel()->transition().progress <
 338           kFinishTransitionThreshold);
 339       event->SetHandled();
 340       return;
 341     case ui::ET_SCROLL_FLING_START: {
 342       GetAppsPaginationModel()->EndScroll(true);
 343       if (fabs(event->details().velocity_x()) > kMinHorizVelocityToSwitchPage) {
 344         GetAppsPaginationModel()->SelectPageRelative(
 345             event->details().velocity_x() < 0 ? 1 : -1, true);
 346       }
 347       event->SetHandled();
 348       return;
 349     }
 350     default:
 351       break;
 352   }
 353 }
 354
 355 void ContentsView::OnScrollEvent(ui::ScrollEvent* event) {
 356   if (!IsNamedPageActive(NAMED_PAGE_APPS) ||
 357       event->type() == ui::ET_SCROLL_FLING_CANCEL) {
 358     return;
 359   }
 360
 361   float offset;
 362   if (std::abs(event->x_offset()) > std::abs(event->y_offset()))
 363     offset = event->x_offset();
 364   else
 365     offset = event->y_offset();
 366
 367   if (std::abs(offset) > kMinScrollToSwitchPage) {
 368     if (!GetAppsPaginationModel()->has_transition()) {
 369       GetAppsPaginationModel()->SelectPageRelative(offset > 0 ? -1 : 1, true);
 370     }
 371     event->SetHandled();
 372     event->StopPropagation();
 373   }
 374 }
 375
 376 }  // namespace app_list