Add descriptive text for omnibox popup result items....

chrome/browser/views/autocomplete/autocomplete_popup_contents_view.cc

 // Copyright (c) 2009 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 "chrome/browser/views/autocomplete/autocomplete_popup_contents_view.h"
 
 #include <dwmapi.h>
 
 #include "chrome/browser/autocomplete/autocomplete_edit_view_win.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
 #include "chrome/browser/views/autocomplete/autocomplete_popup_win.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/gfx/color_utils.h"
 #include "chrome/common/gfx/insets.h"
 #include "chrome/common/gfx/path.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/views/widget/widget.h"
+#include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "skia/include/SkShader.h"
 #include "third_party/icu38/public/common/unicode/ubidi.h"
 
-static const SkColor kTransparentColor = SkColorSetARGB(0, 0, 0, 0);
+// Colors for various components of the view.
+static const SkColor kBackgroundColor =
+    color_utils::GetSysSkColor(COLOR_WINDOW);
+static const SkColor kSelectedBackgroundColor =
+    color_utils::GetSysSkColor(COLOR_HIGHLIGHT);
+static const SkColor kHoverBackgroundColor =
+    SkColorSetA(kSelectedBackgroundColor, 127);
+static const SkColor kTextColor =
+    color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
+static const SkColor kSelectedTextColor =
+    color_utils::GetSysSkColor(COLOR_HIGHLIGHTTEXT);
+static const SkColor kDimTextColor =
+    color_utils::GetSysSkColor(COLOR_GRAYTEXT);
+static const SkColor kSelectedDimTextColor =
+    color_utils::GetSysSkColor(COLOR_HIGHLIGHTTEXT);
 static const SkColor kStandardURLColor = SkColorSetRGB(0, 0x80, 0);
 static const SkColor kHighlightURLColor = SkColorSetRGB(0xD0, 0xFF, 0xD0);
 static const int kPopupTransparency = 235;
 static const int kHoverRowAlpha = 0x40;
 // The minimum distance between the top and bottom of the icon and the top or
 // bottom of the row. "Minimum" is used because the vertical padding may be
 // larger, depending on the size of the text.
 static const int kIconVerticalPadding = 2;
 // The minimum distance between the top and bottom of the text and the top or
 // bottom of the row. See comment about the use of "minimum" for
@@ skipping 26 matching lines @@
   virtual bool OnMouseDragged(const views::MouseEvent& event);
 
  private:
   // Get colors for row backgrounds and text for different row states.
   SkColor GetBackgroundColor() const;
   SkColor GetTextColor() const;
 
   SkBitmap* GetIcon() const;
 
   // Draws the specified |text| into the canvas, using highlighting provided by
-  // |classifications|.
-  void DrawString(ChromeCanvas* canvas,
+  // |classifications|. If |force_dim| is true, ACMatchClassification::DIM is
+  // added to all of the classifications. Returns the x position to the right
+  // of the string.
+  int DrawString(ChromeCanvas* canvas,
                   const std::wstring& text,
                   const ACMatchClassifications& classifications,
+                  bool force_dim,
                   int x,
                   int y);
 
-  // Draws an individual sub-fragment with the specified style.
+  // Draws an individual sub-fragment with the specified style. Returns the x
+  // position to the right of the fragment.
   int DrawStringFragment(ChromeCanvas* canvas,
                          const std::wstring& text,
                          int style,
                          int x,
                          int y);
 
   // Gets the font and text color for a fragment with the specified style.
   ChromeFont GetFragmentFont(int style) const;
   SkColor GetFragmentTextColor(int style) const;
 
@@ skipping 10 matching lines @@
   // A context used for mirroring regions.
   class MirroringContext;
   scoped_ptr<MirroringContext> mirroring_context_;
 
   // Layout rects for various sub-components of the view.
   gfx::Rect icon_bounds_;
   gfx::Rect text_bounds_;
 
   // Icons for rows.
   static SkBitmap* icon_url_;
+  static SkBitmap* icon_url_selected_;
   static SkBitmap* icon_history_;
+  static SkBitmap* icon_history_selected_;
   static SkBitmap* icon_search_;
+  static SkBitmap* icon_search_selected_;
   static SkBitmap* icon_more_;
+  static SkBitmap* icon_more_selected_;
   static SkBitmap* icon_star_;
+  static SkBitmap* icon_star_selected_;
   static int icon_size_;
   
   static bool initialized_;
   static void InitClass();
 
   DISALLOW_COPY_AND_ASSIGN(AutocompleteResultView);
 };
 
 // static
 SkBitmap* AutocompleteResultView::icon_url_ = NULL;
+SkBitmap* AutocompleteResultView::icon_url_selected_ = NULL;
 SkBitmap* AutocompleteResultView::icon_history_ = NULL;
+SkBitmap* AutocompleteResultView::icon_history_selected_ = NULL;
 SkBitmap* AutocompleteResultView::icon_search_ = NULL;
+SkBitmap* AutocompleteResultView::icon_search_selected_ = NULL;
 SkBitmap* AutocompleteResultView::icon_star_ = NULL;
+SkBitmap* AutocompleteResultView::icon_star_selected_ = NULL;
 SkBitmap* AutocompleteResultView::icon_more_ = NULL;
+SkBitmap* AutocompleteResultView::icon_more_selected_ = NULL;
 int AutocompleteResultView::icon_size_ = 0;
 bool AutocompleteResultView::initialized_ = false;
 
 // This class implements a utility used for mirroring x-coordinates when the
 // application language is a right-to-left one.
 class AutocompleteResultView::MirroringContext {
  public:
   MirroringContext() : min_x_(0), center_x_(0), max_x_(0), enabled_(false) { }
 
   // Initializes the bounding region used for mirroring coordinates.
@@ skipping 47 matching lines @@
       mirroring_context_(new MirroringContext()) {
   InitClass();
 }
 
 AutocompleteResultView::~AutocompleteResultView() {
 }
 
 void AutocompleteResultView::Paint(ChromeCanvas* canvas) {
   canvas->FillRectInt(GetBackgroundColor(), 0, 0, width(), height());
 
+  int x = MirroredLeftPointForRect(icon_bounds_);
+
   // Paint the icon.
-  canvas->DrawBitmapInt(*GetIcon(), icon_bounds_.x(), icon_bounds_.y());
+  canvas->DrawBitmapInt(*GetIcon(), x, icon_bounds_.y());
+
+  const AutocompleteMatch& match = model_->GetMatchAtIndex(model_index_);
 
   // Paint the text.
-  const AutocompleteMatch& match = model_->GetMatchAtIndex(model_index_);
-  DrawString(canvas, match.contents, match.contents_class,
-             text_bounds_.x(), text_bounds_.y());
+  x = MirroredLeftPointForRect(text_bounds_);
+  x = DrawString(canvas, match.contents, match.contents_class, false, x,
+                 text_bounds_.y());
 
   // Paint the description.
-  // TODO(beng): do this.
+  if (!match.description.empty()) {
+    std::wstring separator =
+        l10n_util::GetString(IDS_AUTOCOMPLETE_MATCH_DESCRIPTION_SEPARATOR);
+    ACMatchClassifications classifications;
+    classifications.push_back(
+        ACMatchClassification(0, ACMatchClassification::NONE));
+    x = DrawString(canvas, separator, classifications, true, x,
+                   text_bounds_.y());
+
+    x = DrawString(canvas, match.description, match.description_class, true, x,
+               text_bounds_.y());
+  }
 }
 
 void AutocompleteResultView::Layout() {
   icon_bounds_.SetRect(kRowLeftPadding, (height() - icon_size_) / 2,
                        icon_size_, icon_size_);
   int text_x = icon_bounds_.right() + kIconTextSpacing;
   text_bounds_.SetRect(text_x, (height() - font_.height()) / 2,
                        bounds().right() - text_x - kRowRightPadding,
                        font_.height());
 }
@@ skipping 42 matching lines @@
 }
 
 bool AutocompleteResultView::OnMouseDragged(const views::MouseEvent& event) {
   // TODO(beng): move all message handling into the contents view and override
   //             GetViewForPoint.
   return false;
 }
 
 SkColor AutocompleteResultView::GetBackgroundColor() const {
   if (model_->IsSelectedIndex(model_index_))
-    return color_utils::GetSysSkColor(COLOR_HIGHLIGHT);
-  if (hot_) {
-    COLORREF color = GetSysColor(COLOR_HIGHLIGHT);
-    return SkColorSetARGB(kHoverRowAlpha, GetRValue(color), GetGValue(color),
-                          GetBValue(color));
-  }
-  return kTransparentColor;
+    return kSelectedBackgroundColor;
+  return hot_ ? kHoverBackgroundColor : kBackgroundColor;
 }
 
 SkColor AutocompleteResultView::GetTextColor() const {
-  if (model_->IsSelectedIndex(model_index_))
-    return color_utils::GetSysSkColor(COLOR_HIGHLIGHTTEXT);
-  return color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
+  return model_->IsSelectedIndex(model_index_) ? kSelectedTextColor
+                                               : kTextColor;
 }
 
 SkBitmap* AutocompleteResultView::GetIcon() const {
+  bool selected = model_->IsSelectedIndex(model_index_);
   switch (model_->GetMatchAtIndex(model_index_).type) {
     case AutocompleteMatch::URL_WHAT_YOU_TYPED:
     case AutocompleteMatch::HISTORY_URL:
     case AutocompleteMatch::NAVSUGGEST:
-      return icon_url_;
+      return selected ? icon_url_selected_ : icon_url_;
     case AutocompleteMatch::HISTORY_TITLE:
     case AutocompleteMatch::HISTORY_BODY:
     case AutocompleteMatch::HISTORY_KEYWORD:
-      return icon_history_;
+      return selected ? icon_history_selected_ : icon_history_;
     case AutocompleteMatch::SEARCH_WHAT_YOU_TYPED:
     case AutocompleteMatch::SEARCH_HISTORY:
     case AutocompleteMatch::SEARCH_SUGGEST:
     case AutocompleteMatch::SEARCH_OTHER_ENGINE:
-      return icon_search_;
+      return selected ? icon_search_selected_ : icon_search_;
     case AutocompleteMatch::OPEN_HISTORY_PAGE:
-      return icon_more_;
+      return selected ? icon_more_selected_ : icon_more_;
     default:
       NOTREACHED();
       break;
   }
   return NULL;
 }
 
-void AutocompleteResultView::DrawString(
+int AutocompleteResultView::DrawString(
     ChromeCanvas* canvas,
     const std::wstring& text,
     const ACMatchClassifications& classifications,
+    bool force_dim,
     int x,
     int y) {
   if (!text.length())
-    return;
+    return x;
 
   // Check whether or not this text is a URL string.
   // A URL string is basically in English with possible included words in
   // Arabic or Hebrew. For such case, ICU provides a special algorithm and we
   // should use it.
   bool url = false;
   for (ACMatchClassifications::const_iterator i = classifications.begin();
        i != classifications.end(); ++i) {
     if (i->style & ACMatchClassification::URL)
       url = true;
   }
 
   // Initialize a bidirectional line iterator of ICU and split the text into
   // visual runs. (A visual run is consecutive characters which have the same
   // display direction and should be displayed at once.)
   l10n_util::BiDiLineIterator bidi_line;
   if (!bidi_line.Open(text, mirroring_context_->enabled(), url))
-    return;
+    return x;
   const int runs = bidi_line.CountRuns();
 
   // Draw the visual runs.
   // This loop splits each run into text fragments with the given
   // classifications and draws the text fragments.
   // When the direction of a run is right-to-left, we have to mirror the
   // x-coordinate of this run and render the fragments in the right-to-left
   // reading order. To handle this display order independently from the one of
   // this popup window, this loop renders a run with the steps below:
   // 1. Create a local display context for each run;
@@ skipping 23 matching lines @@
                                                                 &run_length);
     const int run_end = run_start + run_length;
 
     // Split this run with the given classifications and draw the fragments
     // into the local display context.
     for (ACMatchClassifications::const_iterator i = classifications.begin();
          i != classifications.end(); ++i) {
       const int text_start = std::max(run_start, static_cast<int>(i->offset));
       const int text_end = std::min(run_end, (i != classifications.end() - 1) ?
           static_cast<int>((i + 1)->offset) : run_end);
+      int style = i->style;
+      if (force_dim)
+        style |= ACMatchClassification::DIM;
       x += DrawStringFragment(canvas,
                               text.substr(text_start, text_end - text_start),
-                              i->style, x, y);
+                              style, x, y);
     }
   }
+  return x;
 }
 
 int AutocompleteResultView::DrawStringFragment(
     ChromeCanvas* canvas,
     const std::wstring& text,
     int style,
     int x,
     int y) {
   ChromeFont display_font = GetFragmentFont(style);
   int string_width = display_font.GetStringWidth(text);
   canvas->DrawStringInt(text, GetFragmentFont(style),
                         GetFragmentTextColor(style), x, y, string_width,
                         display_font.height());
   return string_width;
 }
 
 ChromeFont AutocompleteResultView::GetFragmentFont(int style) const {
   if (style & ACMatchClassification::MATCH)
     return font_.DeriveFont(0, ChromeFont::BOLD);
   return font_;
 }
 
 SkColor AutocompleteResultView::GetFragmentTextColor(int style) const {
+  bool selected = model_->IsSelectedIndex(model_index_);
   if (style & ACMatchClassification::URL) {
     // TODO(beng): bring over the contrast logic from the old popup and massage
     //             these values. See autocomplete_popup_view_win.cc and
     //             LuminosityContrast etc.
-    return model_->IsSelectedIndex(model_index_) ? kHighlightURLColor
-                                                 : kStandardURLColor;
+    return selected ? kHighlightURLColor : kStandardURLColor;
   }
-
   if (style & ACMatchClassification::DIM)
-    return SkColorSetA(GetTextColor(), 0xAA);
+    return selected ? kSelectedDimTextColor : kDimTextColor;
   return GetTextColor();
 }
 
 void AutocompleteResultView::InitClass() {
   if (!initialized_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     icon_url_ = rb.GetBitmapNamed(IDR_O2_GLOBE);
+    icon_url_selected_ = rb.GetBitmapNamed(IDR_O2_GLOBE_SELECTED);
     icon_history_ = rb.GetBitmapNamed(IDR_O2_HISTORY);
+    icon_history_selected_ = rb.GetBitmapNamed(IDR_O2_HISTORY_SELECTED);
     icon_search_ = rb.GetBitmapNamed(IDR_O2_SEARCH);
+    icon_search_selected_ = rb.GetBitmapNamed(IDR_O2_SEARCH_SELECTED);
     icon_star_ = rb.GetBitmapNamed(IDR_O2_STAR);
+    icon_star_selected_ = rb.GetBitmapNamed(IDR_O2_STAR_SELECTED);
     icon_more_ = rb.GetBitmapNamed(IDR_O2_MORE);
+    icon_more_selected_ = rb.GetBitmapNamed(IDR_O2_MORE_SELECTED);
     // All icons are assumed to be square, and the same size.
     icon_size_ = icon_url_->width();
     initialized_ = true;
   }
 }
 
 class PopupBorder : public views::Border {
  public:
   PopupBorder() {
     InitClass();
@@ skipping 106 matching lines @@
       popup_positioner_(popup_positioner),
       edit_font_(font) {
   set_border(new PopupBorder);
 }
 
 void AutocompletePopupContentsView::UpdateResultViewsFromResult(
     const AutocompleteResult& result) {
   RemoveAllChildViews(true);
   for (size_t i = 0; i < result.size(); ++i)
     AddChildView(new AutocompleteResultView(this, i, edit_font_));
+
+  // Need to schedule a paint here because if we don't and our result count
+  // hasn't changed since last time we were shown, we may not repaint to
+  // show selection changes.
+  SchedulePaint();
 }
 
 gfx::Rect AutocompletePopupContentsView::GetPopupBounds() const {
   gfx::Insets insets;
   border()->GetInsets(&insets);
   gfx::Rect contents_bounds = popup_positioner_->GetPopupBounds();
   int child_count = GetChildViewCount();
   int height = 0;
   for (int i = 0; i < child_count; ++i)
     height += GetChildViewAt(i)->GetPreferredSize().height();
@@ skipping 84 matching lines @@
   // We paint our children in an unconventional way.
   //
   // Because the border of this view creates an anti-aliased round-rect region
   // for the contents, we need to render our rectangular result child views into
   // this round rect region. We can't use a simple clip because clipping is
   // 1-bit and we get nasty jagged edges.
   //
   // Instead, we paint all our children into a second canvas and use that as a
   // shader to fill a path representing the round-rect clipping region. This
   // yields a nice anti-aliased edge.
-  gfx::Rect contents_rect = GetLocalBounds(false);
-  ChromeCanvas contents_canvas(contents_rect.width(), contents_rect.height(),
-                               true);
-  contents_canvas.FillRectInt(color_utils::GetSysSkColor(COLOR_WINDOW), 0, 0,
-                              contents_rect.width(), contents_rect.height());
+  ChromeCanvas contents_canvas(width(), height(), true);
+  contents_canvas.FillRectInt(kBackgroundColor, 0, 0, width(), height());
   View::PaintChildren(&contents_canvas);
   // We want the contents background to be slightly transparent so we can see
   // the blurry glass effect on DWM systems behind. We do this _after_ we paint
   // the children since they paint text, and GDI will reset this alpha data if
   // we paint text after this call.
   MakeCanvasTransparent(&contents_canvas);
 
   // Now paint the contents of the contents canvas into the actual canvas.
   SkPaint paint;
   paint.setAntiAlias(true);
 
   SkShader* shader = SkShader::CreateBitmapShader(
       contents_canvas.getDevice()->accessBitmap(false),
-      SkShader::kClamp_TileMode,
-      SkShader::kClamp_TileMode);
+      SkShader::kRepeat_TileMode,
+      SkShader::kRepeat_TileMode);
   paint.setShader(shader);
   shader->unref();
 
   gfx::Path path;
-  MakeContentsPath(&path, contents_rect);
+  MakeContentsPath(&path, GetLocalBounds(false));
   canvas->drawPath(path, paint);
 }
 
 void AutocompletePopupContentsView::Layout() {
   UpdateBlurRegion();
 
   // Size our children to the available content area.
   gfx::Rect contents_rect = GetLocalBounds(false);
   int child_count = GetChildViewCount();
   int top = contents_rect.y();
@@ skipping 51 matching lines @@
     ChromeCanvas* canvas) {
   // Allow the window blur effect to show through the popup background.
   SkPaint paint;
   paint.setColor(SkColorSetARGB(kPopupTransparency, 255, 255, 255));
   paint.setPorterDuffXfermode(SkPorterDuff::kDstIn_Mode);
   paint.setStyle(SkPaint::kFill_Style);
   canvas->FillRectInt(0, 0, canvas->getDevice()->width(),
                       canvas->getDevice()->height(), paint);
 }