Enabled pressing TAB to cycle through the Omnibox results.

chrome/browser/ui/views/autocomplete/autocomplete_result_view.cc

 // Copyright (c) 2011 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.
 
 // For WinDDK ATL compatibility, these ATL headers must come first.
 #include "build/build_config.h"
 #if defined(OS_WIN)
 #include <atlbase.h>  // NOLINT
 #include <atlwin.h>  // NOLINT
 #endif
 
 #include "chrome/browser/ui/views/autocomplete/autocomplete_result_view.h"
 
 #include <algorithm>  // NOLINT
 
 #include "base/i18n/bidi_line_iterator.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/ui/views/autocomplete/autocomplete_result_view_model.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/color_utils.h"
+#include "views/controls/image_view.h"
+#include "views/controls/label.h"
 
 #if defined(OS_LINUX)
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "ui/gfx/skia_utils_gtk.h"
 #endif
 
 namespace {
 
 const char16 kEllipsis[] = { 0x2026 };
 
@@ skipping 63 matching lines @@
     return right_ - x;
   }
 
  private:
   int center_;
   int right_;
 
   DISALLOW_COPY_AND_ASSIGN(MirroringContext);
 };
 
+class AutocompleteResultView::IconLabelView : public views::View {
+  static const int kLineOffset = 1;

[Peter Kasting, 2011/04/07 20:19:21]

Nit: Declare in private section, or in the function which needs them, if only
one.

Also, my mock was a quick job in Paint; see if you can eliminate many or all of
these constants via shared code or constants with the overall result view.  In
other words, make the spacing between divider and icon, icon and text, and text
and edge match those for a normal match.

+  static const int kLinePadding = 2;
+  static const int kEdgeOffset = 2;
+  static const int kIconPadding = 3;
+  static const int kLabelEdgePadding = 5;
+
+ public:
+  IconLabelView::IconLabelView(gfx::Font font) {

[Peter Kasting, 2011/04/07 20:19:21]

Nit: Write definitions out-of-line, even for classes declared in .cc files

+    image_ = new views::ImageView();
+    AddChildView(image_);
+    image_->SetImage(
+      ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_OMNIBOX_SEARCH));
+    label_ = new views::Label();
+    AddChildView(label_);
+    label_->SetFont(font);
+    label_->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
+  }
+
+  virtual void Layout() {
+    const int icon_width = image_->GetPreferredSize().width();
+    image_->SetBounds(kEdgeOffset + kIconPadding, (height() - icon_width) / 2,
+      icon_width, icon_width);
+    const int label_padding = icon_width + kEdgeOffset + kIconPadding +
+      LocationBarView::kItemPadding;
+    const int label_height = label_->GetPreferredSize().height();
+    label_->SetBounds(label_padding, (height() - label_height) / 2, width() -
+      label_padding, label_height);
+  }
+
+  virtual gfx::Size GetPreferredSize() {
+    gfx::Size size(image_->GetPreferredSize());
+    size.Enlarge(label_->GetPreferredSize().width() + kLabelEdgePadding +
+      kEdgeOffset + kIconPadding + LocationBarView::kItemPadding, 0);
+    return size;
+  }
+
+  virtual void OnPaint(gfx::Canvas* canvas) {
+    if (selected) {
+      canvas->Save();
+      canvas->ClipRectInt(kEdgeOffset, 0, width() - kEdgeOffset, height());
+      canvas->AsCanvasSkia()->drawColor(GetColor(SELECTED, BACKGROUND));
+      canvas->Restore();
+    } else {
+      canvas->AsCanvasSkia()->drawColor(GetColor(NORMAL, BACKGROUND));
+    }
+
+    SkPaint paint;
+    paint.setColor(GetColor(NORMAL, DIMMED_TEXT));
+    paint.setStrokeWidth(SkIntToScalar(1));
+    paint.setAntiAlias(true);
+
+    canvas->AsCanvasSkia()->drawLine(SkIntToScalar(kLineOffset),
+      SkIntToScalar(kLinePadding), SkIntToScalar(kLineOffset),
+      SkIntToScalar(height() - kLinePadding * 2), paint);
+  }
+
+  void SetLabelColor(SkColor color) {
+    label_->SetColor(color);
+  }
+
+  void SetLabelText(const string16& text) {
+    label_->SetText(UTF16ToWide(text));
+  }
+
+  void SetSelected(bool flag) {
+    selected = flag;
+
+    if (selected)
+      image_->SetImage(
+        ResourceBundle::GetSharedInstance().
+          GetBitmapNamed(IDR_OMNIBOX_SEARCH_SELECTED));
+    else
+      image_->SetImage(
+        ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_OMNIBOX_SEARCH));
+
+    SchedulePaint();
+  }
+
+ private:
+  views::ImageView* image_;
+  views::Label* label_;
+  bool selected;
+};
+
 AutocompleteResultView::AutocompleteResultView(
     AutocompleteResultViewModel* model,
     int model_index,
     const gfx::Font& font,
     const gfx::Font& bold_font)
     : icon_vertical_padding_(kMinimumIconVerticalPadding),
       text_vertical_padding_(kMinimumTextVerticalPadding),
       model_(model),
       model_index_(model_index),
       normal_font_(font),
       bold_font_(bold_font),
       ellipsis_width_(font.GetStringWidth(string16(kEllipsis))),
       mirroring_context_(new MirroringContext()),
-      match_(NULL, 0, false, AutocompleteMatch::URL_WHAT_YOU_TYPED) {
+      match_(NULL, 0, false, AutocompleteMatch::URL_WHAT_YOU_TYPED),
+      search_view_(new IconLabelView(font)),
+      search_expanded_(false) {
   CHECK_GE(model_index, 0);
   if (icon_size_ == 0) {
     icon_size_ = ResourceBundle::GetSharedInstance().GetBitmapNamed(
         AutocompleteMatch::TypeToIcon(AutocompleteMatch::URL_WHAT_YOU_TYPED))->
         width();
   }
+
+  animation_.reset(new ui::SlideAnimation(this));

[Peter Kasting, 2011/04/07 20:19:21]

Nit: You can do this in the initializer list (use
ALLOW_THIS_IN_INITIALIZER_LIST() if necessary)

+  animation_->SetSlideDuration(500);
+
+  AddChildView(search_view_.get());
 }
 
 AutocompleteResultView::~AutocompleteResultView() {
 }
 
 void AutocompleteResultView::OnPaint(gfx::Canvas* canvas) {
   const ResultViewState state = GetState();
-  if (state != NORMAL)
+
+  if (state != NORMAL && !search_expanded_)
     canvas->AsCanvasSkia()->drawColor(GetColor(state, BACKGROUND));
 
   // Paint the icon.
   canvas->DrawBitmapInt(*GetIcon(), GetMirroredXForRect(icon_bounds_),
                         icon_bounds_.y());
 
   // Paint the text.
   int x = GetMirroredXForRect(text_bounds_);
   mirroring_context_->Initialize(x, text_bounds_.width());
   PaintMatch(canvas, match_, x);
 }
 
 void AutocompleteResultView::Layout() {
   icon_bounds_.SetRect(LocationBarView::kEdgeItemPadding,
                        (height() - icon_size_) / 2, icon_size_, icon_size_);
-  int text_x = icon_bounds_.right() + LocationBarView::kItemPadding;
-  int font_height = std::max(normal_font_.GetHeight(), bold_font_.GetHeight());
-  text_bounds_.SetRect(text_x, std::max(0, (height() - font_height) / 2),
-      std::max(bounds().width() - text_x - LocationBarView::kEdgeItemPadding,
-      0), font_height);
+  const int text_x = icon_bounds_.right() + LocationBarView::kItemPadding;
+  const int font_height = std::max(normal_font_.GetHeight(),
+    bold_font_.GetHeight());
+  const int text_y = std::max(0, (height() - font_height) / 2);
+
+  if (keyword_.get() && keyword_->is_keyword_hint) {
+    gfx::Size search_size = search_view_->GetPreferredSize();
+    const double expanded_x = text_x +

[Peter Kasting, 2011/04/07 20:19:21]

Nit: float is plenty of precision, no need for double

+      normal_font_.GetStringWidth(UTF8ToUTF16(ui::kEllipsis)) +
+      LocationBarView::kItemPadding;
+    const double collapsed_x = bounds().width() - search_size.width();
+    const int search_x = static_cast<int>(collapsed_x - ((collapsed_x -
+      expanded_x) * animation_->GetCurrentValue()));
+
+    text_bounds_.SetRect(text_x, text_y, std::max(search_x - text_x, 0),
+      font_height);
+    search_view_->SetBounds(search_x, 0, std::max(bounds().width() -
+      search_x, 0), height());
+  } else {
+    text_bounds_.SetRect(text_x, text_y,
+      std::max(bounds().width() - text_x, 0), font_height);
+  }
 }
 
 gfx::Size AutocompleteResultView::GetPreferredSize() {
   return gfx::Size(0, GetPreferredHeight(normal_font_, bold_font_));
 }
 
 int AutocompleteResultView::GetPreferredHeight(
     const gfx::Font& font,
     const gfx::Font& bold_font) {
   int text_height = std::max(font.GetHeight(), bold_font.GetHeight()) +
@@ skipping 95 matching lines @@
   return model_->IsHoveredIndex(model_index_) ? HOVERED : NORMAL;
 }
 
 const SkBitmap* AutocompleteResultView::GetIcon() const {
   const SkBitmap* bitmap = model_->GetSpecialIcon(model_index_);
   if (bitmap)
     return bitmap;
 
   int icon = match_.starred ?
       IDR_OMNIBOX_STAR : AutocompleteMatch::TypeToIcon(match_.type);
-  if (model_->IsSelectedIndex(model_index_)) {
+  if (model_->IsSelectedIndex(model_index_) && !search_expanded_) {
     switch (icon) {
       case IDR_OMNIBOX_HTTP:    icon = IDR_OMNIBOX_HTTP_SELECTED; break;
       case IDR_OMNIBOX_HISTORY: icon = IDR_OMNIBOX_HISTORY_SELECTED; break;
       case IDR_OMNIBOX_SEARCH:  icon = IDR_OMNIBOX_SEARCH_SELECTED; break;
       case IDR_OMNIBOX_STAR:    icon = IDR_OMNIBOX_STAR_SELECTED; break;
       default:             NOTREACHED(); break;
     }
   }
   return ResourceBundle::GetSharedInstance().GetBitmapNamed(icon);
 }
@@ skipping 64 matching lines @@
 
       current_run->classifications.push_back(ClassificationData());
       ClassificationData* current_data =
           &current_run->classifications.back();
       current_data->text = text.substr(text_start, text_end - text_start);
 
       // Calculate style-related data.
       const int style = classifications[i].style;
       const bool use_bold_font = !!(style & ACMatchClassification::MATCH);
       current_data->font = &(use_bold_font ? bold_font_ : normal_font_);
-      const ResultViewState state = GetState();
+      const ResultViewState state = search_expanded_ ? NORMAL : GetState();
       if (style & ACMatchClassification::URL)
         current_data->color = GetColor(state, URL);
       else if (style & ACMatchClassification::DIM)
         current_data->color = GetColor(state, DIMMED_TEXT);
       else
         current_data->color = GetColor(state, force_dim ? DIMMED_TEXT : TEXT);
       current_data->pixel_width =
           current_data->font->GetStringWidth(current_data->text);
       current_run->pixel_width += current_data->pixel_width;
     }
@@ skipping 135 matching lines @@
       //   * It's normal, and will be able to draw successfully with the
       //     ellipsis we'll append to it, or
       //   * It is also bold, in which case we don't want to fall back
       //     to a normal ellipsis anyway (see comment above).
     }
   }
 
   // We couldn't draw anything.
   runs->clear();
 }
+
+void AutocompleteResultView::SetMatch(const AutocompleteMatch& match) {
+  const bool same_match = match.destination_url == match_.destination_url;
+  match_ = match;
+  keyword_ = match.keyword;
+
+  const bool keyword_mode = keyword_.get() && keyword_->is_keyword_hint &&
+    keyword_->is_keyword_mode;
+
+  if (keyword_mode && !search_expanded_)
+    animation_->Show();
+  else if (same_match && !keyword_mode && search_expanded_)
+    animation_->Hide();
+  else if (!same_match || (same_match && !animation_->is_animating())) {
+    animation_->Stop();
+    animation_->Reset();
+  }
+
+  search_expanded_ = keyword_mode;
+  search_view_->SetSelected(search_expanded_);
+  search_view_->SetVisible(keyword_.get() && keyword_->is_keyword_hint);
+
+  if (search_expanded_) {
+    int message_id = keyword_->template_url->IsExtensionKeyword() ?
+      IDS_EXTENSION_KEYWORD_COMMAND : IDS_KEYWORD_SEARCH;
+    string16 text = l10n_util::GetStringFUTF16(message_id,
+      keyword_->text, l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE));
+    text.append(
+      l10n_util::GetStringUTF16(IDS_AUTOCOMPLETE_MATCH_DESCRIPTION_SEPARATOR));
+    text.append(
+      l10n_util::GetStringFUTF16(IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION,
+      keyword_->text));
+    search_view_->SetLabelText(text);
+    search_view_->SetLabelColor(GetColor(SELECTED, DIMMED_TEXT));
+  } else {
+    search_view_->SetLabelText(UTF8ToUTF16(ui::kEllipsis));
+    search_view_->SetLabelColor(GetColor(NORMAL, DIMMED_TEXT));
+  }
+  Layout();
+}
+
+void AutocompleteResultView::AnimationProgressed(const ui::Animation* animation) {
+  Layout();
+  SchedulePaint();
+}
+
+void AutocompleteResultView::AnimationCanceled(const ui::Animation* animation) {
+  Layout();
+  SchedulePaint();
+}