ui/app_list/views/search_result_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/search_result_view.h"
   6
   7 #include <algorithm>
   8
   9 #include "ui/app_list/app_list_constants.h"
  10 #include "ui/app_list/search_result.h"
  11 #include "ui/app_list/views/progress_bar_view.h"
  12 #include "ui/app_list/views/search_result_actions_view.h"
  13 #include "ui/app_list/views/search_result_list_view.h"
  14 #include "ui/gfx/canvas.h"
  15 #include "ui/gfx/font.h"
  16 #include "ui/gfx/image/image_skia_operations.h"
  17 #include "ui/gfx/render_text.h"
  18 #include "ui/views/controls/button/image_button.h"
  19 #include "ui/views/controls/image_view.h"
  20 #include "ui/views/controls/menu/menu_runner.h"
  21
  22 namespace app_list {
  23
  24 namespace {
  25
  26 const int kPreferredWidth = 300;
  27 const int kPreferredHeight = 52;
  28 const int kIconDimension = 32;
  29 const int kIconPadding = 14;
  30 const int kIconViewWidth = kIconDimension + 2 * kIconPadding;
  31 const int kTextTrailPadding = kIconPadding;
  32 const int kBorderSize = 1;
  33
  34 // Extra margin at the right of the rightmost action icon.
  35 const int kActionButtonRightMargin = 8;
  36
  37 // Creates a RenderText of given |text| and |styles|. Caller takes ownership
  38 // of returned RenderText.
  39 gfx::RenderText* CreateRenderText(const base::string16& text,
  40                                   const SearchResult::Tags& tags) {
  41   gfx::RenderText* render_text = gfx::RenderText::CreateInstance();
  42   render_text->SetText(text);
  43   render_text->SetColor(kResultDefaultTextColor);
  44
  45   for (SearchResult::Tags::const_iterator it = tags.begin();
  46        it != tags.end();
  47        ++it) {
  48     // NONE means default style so do nothing.
  49     if (it->styles == SearchResult::Tag::NONE)
  50       continue;
  51
  52     if (it->styles & SearchResult::Tag::MATCH)
  53       render_text->ApplyStyle(gfx::BOLD, true, it->range);
  54     if (it->styles & SearchResult::Tag::DIM)
  55       render_text->ApplyColor(kResultDimmedTextColor, it->range);
  56     else if (it->styles & SearchResult::Tag::URL)
  57       render_text->ApplyColor(kResultURLTextColor, it->range);
  58   }
  59
  60   return render_text;
  61 }
  62
  63 }  // namespace
  64
  65 // static
  66 const char SearchResultView::kViewClassName[] = "ui/app_list/SearchResultView";
  67
  68 SearchResultView::SearchResultView(SearchResultListView* list_view)
  69     : views::CustomButton(this),
  70       result_(NULL),
  71       list_view_(list_view),
  72       icon_(new views::ImageView),
  73       actions_view_(new SearchResultActionsView(this)),
  74       progress_bar_(new ProgressBarView) {
  75   icon_->set_interactive(false);
  76
  77   AddChildView(icon_);
  78   AddChildView(actions_view_);
  79   AddChildView(progress_bar_);
  80   set_context_menu_controller(this);
  81 }
  82
  83 SearchResultView::~SearchResultView() {
  84   ClearResultNoRepaint();
  85 }
  86
  87 void SearchResultView::SetResult(SearchResult* result) {
  88   ClearResultNoRepaint();
  89
  90   result_ = result;
  91   if (result_)
  92     result_->AddObserver(this);
  93
  94   OnIconChanged();
  95   OnActionsChanged();
  96   UpdateTitleText();
  97   UpdateDetailsText();
  98   OnIsInstallingChanged();
  99   SchedulePaint();
 100 }
 101
 102 void SearchResultView::ClearResultNoRepaint() {
 103   if (result_)
 104     result_->RemoveObserver(this);
 105   result_ = NULL;
 106 }
 107
 108 void SearchResultView::ClearSelectedAction() {
 109   actions_view_->SetSelectedAction(-1);
 110 }
 111
 112 void SearchResultView::UpdateTitleText() {
 113   if (!result_ || result_->title().empty()) {
 114     title_text_.reset();
 115     SetAccessibleName(base::string16());
 116   } else {
 117     title_text_.reset(CreateRenderText(result_->title(),
 118                                        result_->title_tags()));
 119     SetAccessibleName(result_->title());
 120   }
 121 }
 122
 123 void SearchResultView::UpdateDetailsText() {
 124   if (!result_ || result_->details().empty()) {
 125     details_text_.reset();
 126   } else {
 127     details_text_.reset(CreateRenderText(result_->details(),
 128                                          result_->details_tags()));
 129   }
 130 }
 131
 132 const char* SearchResultView::GetClassName() const {
 133   return kViewClassName;
 134 }
 135
 136 gfx::Size SearchResultView::GetPreferredSize() const {
 137   return gfx::Size(kPreferredWidth, kPreferredHeight);
 138 }
 139
 140 void SearchResultView::Layout() {
 141   gfx::Rect rect(GetContentsBounds());
 142   if (rect.IsEmpty())
 143     return;
 144
 145   gfx::Rect icon_bounds(rect);
 146   icon_bounds.set_width(kIconViewWidth);
 147   icon_bounds.Inset(kIconPadding, (rect.height() - kIconDimension) / 2);
 148   icon_bounds.Intersect(rect);
 149   icon_->SetBoundsRect(icon_bounds);
 150
 151   const int max_actions_width =
 152       (rect.right() - kActionButtonRightMargin - icon_bounds.right()) / 2;
 153   int actions_width = std::min(max_actions_width,
 154                                actions_view_->GetPreferredSize().width());
 155
 156   gfx::Rect actions_bounds(rect);
 157   actions_bounds.set_x(rect.right() - kActionButtonRightMargin - actions_width);
 158   actions_bounds.set_width(actions_width);
 159   actions_view_->SetBoundsRect(actions_bounds);
 160
 161   const int progress_width = rect.width() / 5;
 162   const int progress_height = progress_bar_->GetPreferredSize().height();
 163   const gfx::Rect progress_bounds(
 164       rect.right() - kActionButtonRightMargin - progress_width,
 165       rect.y() + (rect.height() - progress_height) / 2,
 166       progress_width,
 167       progress_height);
 168   progress_bar_->SetBoundsRect(progress_bounds);
 169 }
 170
 171 bool SearchResultView::OnKeyPressed(const ui::KeyEvent& event) {
 172   // |result_| could be NULL when result list is changing.
 173   if (!result_)
 174     return false;
 175
 176   switch (event.key_code()) {
 177     case ui::VKEY_TAB: {
 178       int new_selected = actions_view_->selected_action()
 179           + (event.IsShiftDown() ? -1 : 1);
 180       actions_view_->SetSelectedAction(new_selected);
 181       return actions_view_->IsValidActionIndex(new_selected);
 182     }
 183     case ui::VKEY_RETURN: {
 184       int selected = actions_view_->selected_action();
 185       if (actions_view_->IsValidActionIndex(selected)) {
 186         OnSearchResultActionActivated(selected, event.flags());
 187       } else {
 188         list_view_->SearchResultActivated(this, event.flags());
 189       }
 190       return true;
 191     }
 192     default:
 193       break;
 194   }
 195
 196   return false;
 197 }
 198
 199 void SearchResultView::ChildPreferredSizeChanged(views::View* child) {
 200   Layout();
 201 }
 202
 203 void SearchResultView::OnPaint(gfx::Canvas* canvas) {
 204   gfx::Rect rect(GetContentsBounds());
 205   if (rect.IsEmpty())
 206     return;
 207
 208   gfx::Rect content_rect(rect);
 209   content_rect.set_height(rect.height() - kBorderSize);
 210
 211   const bool selected = list_view_->IsResultViewSelected(this);
 212   const bool hover = state() == STATE_HOVERED || state() == STATE_PRESSED;
 213   if (selected)
 214     canvas->FillRect(content_rect, kSelectedColor);
 215   else if (hover)
 216     canvas->FillRect(content_rect, kHighlightedColor);
 217   else
 218     canvas->FillRect(content_rect, kContentsBackgroundColor);
 219
 220   gfx::Rect border_bottom = gfx::SubtractRects(rect, content_rect);
 221   canvas->FillRect(border_bottom, kResultBorderColor);
 222
 223   gfx::Rect text_bounds(rect);
 224   text_bounds.set_x(kIconViewWidth);
 225   if (actions_view_->visible()) {
 226     text_bounds.set_width(
 227         rect.width() - kIconViewWidth - kTextTrailPadding -
 228         actions_view_->bounds().width() -
 229         (actions_view_->has_children() ? kActionButtonRightMargin : 0));
 230   } else {
 231     text_bounds.set_width(
 232         rect.width() - kIconViewWidth - kTextTrailPadding -
 233         progress_bar_->bounds().width() - kActionButtonRightMargin);
 234   }
 235   text_bounds.set_x(GetMirroredXWithWidthInView(text_bounds.x(),
 236                                                 text_bounds.width()));
 237
 238   if (title_text_ && details_text_) {
 239     gfx::Size title_size(text_bounds.width(),
 240                          title_text_->GetStringSize().height());
 241     gfx::Size details_size(text_bounds.width(),
 242                            details_text_->GetStringSize().height());
 243     int total_height = title_size.height() + + details_size.height();
 244     int y = text_bounds.y() + (text_bounds.height() - total_height) / 2;
 245
 246     title_text_->SetDisplayRect(gfx::Rect(gfx::Point(text_bounds.x(), y),
 247                                           title_size));
 248     title_text_->Draw(canvas);
 249
 250     y += title_size.height();
 251     details_text_->SetDisplayRect(gfx::Rect(gfx::Point(text_bounds.x(), y),
 252                                             details_size));
 253     details_text_->Draw(canvas);
 254   } else if (title_text_) {
 255     gfx::Size title_size(text_bounds.width(),
 256                          title_text_->GetStringSize().height());
 257     gfx::Rect centered_title_rect(text_bounds);
 258     centered_title_rect.ClampToCenteredSize(title_size);
 259     title_text_->SetDisplayRect(centered_title_rect);
 260     title_text_->Draw(canvas);
 261   }
 262 }
 263
 264 void SearchResultView::ButtonPressed(views::Button* sender,
 265                                      const ui::Event& event) {
 266   DCHECK(sender == this);
 267
 268   list_view_->SearchResultActivated(this, event.flags());
 269 }
 270
 271 void SearchResultView::OnIconChanged() {
 272   gfx::ImageSkia image(result_ ? result_->icon() : gfx::ImageSkia());
 273   // Note this might leave the view with an old icon. But it is needed to avoid
 274   // flash when a SearchResult's icon is loaded asynchronously. In this case, it
 275   // looks nicer to keep the stale icon for a little while on screen instead of
 276   // clearing it out. It should work correctly as long as the SearchResult does
 277   // not forget to SetIcon when it's ready.
 278   if (image.isNull())
 279     return;
 280
 281   // Scales down big icons but leave small ones unchanged.
 282   if (image.width() > kIconDimension || image.height() > kIconDimension) {
 283     image = gfx::ImageSkiaOperations::CreateResizedImage(
 284         image,
 285         skia::ImageOperations::RESIZE_BEST,
 286         gfx::Size(kIconDimension, kIconDimension));
 287   } else {
 288     icon_->ResetImageSize();
 289   }
 290
 291   // Set the image to an empty image before we reset the image because
 292   // since we're using the same backing store for our images, sometimes
 293   // ImageView won't detect that we have a new image set due to the pixel
 294   // buffer pointers remaining the same despite the image changing.
 295   icon_->SetImage(gfx::ImageSkia());
 296   icon_->SetImage(image);
 297 }
 298
 299 void SearchResultView::OnActionsChanged() {
 300   actions_view_->SetActions(result_ ? result_->actions()
 301                                     : SearchResult::Actions());
 302 }
 303
 304 void SearchResultView::OnIsInstallingChanged() {
 305   const bool is_installing = result_ && result_->is_installing();
 306   actions_view_->SetVisible(!is_installing);
 307   progress_bar_->SetVisible(is_installing);
 308 }
 309
 310 void SearchResultView::OnPercentDownloadedChanged() {
 311   progress_bar_->SetValue(result_ ? result_->percent_downloaded() / 100.0 : 0);
 312 }
 313
 314 void SearchResultView::OnItemInstalled() {
 315   list_view_->OnSearchResultInstalled(this);
 316 }
 317
 318 void SearchResultView::OnItemUninstalled() {
 319   list_view_->OnSearchResultUninstalled(this);
 320 }
 321
 322 void SearchResultView::OnSearchResultActionActivated(size_t index,
 323                                                      int event_flags) {
 324   // |result_| could be NULL when result list is changing.
 325   if (!result_)
 326     return;
 327
 328   DCHECK_LT(index, result_->actions().size());
 329
 330   list_view_->SearchResultActionActivated(this, index, event_flags);
 331 }
 332
 333 void SearchResultView::ShowContextMenuForView(views::View* source,
 334                                               const gfx::Point& point,
 335                                               ui::MenuSourceType source_type) {
 336   // |result_| could be NULL when result list is changing.
 337   if (!result_)
 338     return;
 339
 340   ui::MenuModel* menu_model = result_->GetContextMenuModel();
 341   if (!menu_model)
 342     return;
 343
 344   context_menu_runner_.reset(new views::MenuRunner(menu_model));
 345   if (context_menu_runner_->RunMenuAt(GetWidget(),
 346                                       NULL,
 347                                       gfx::Rect(point, gfx::Size()),
 348                                       views::MENU_ANCHOR_TOPLEFT,
 349                                       source_type,
 350                                       views::MenuRunner::HAS_MNEMONICS) ==
 351       views::MenuRunner::MENU_DELETED)
 352     return;
 353 }
 354
 355 }  // namespace app_list