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