Merge 25494 - Use system themes where possible in Omnibox edit and dropdown; ...

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 <objidl.h>
 #include <commctrl.h>
 #include <dwmapi.h>
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
 #include "app/gfx/insets.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/theme_provider.h"
 #include "app/win_util.h"
 #include "base/compiler_specific.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 "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/icu38/public/common/unicode/ubidi.h"
 #include "views/widget/widget.h"
 
-// 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 kGlassPopupTransparency = 240;
-static const int kOpaquePopupTransparency = 255;
-static const int kHoverRowAlpha = 0x40;
+namespace {
+
+enum ResultViewState {
+  NORMAL = 0,
+  SELECTED,
+  HOVERED,
+  NUM_STATES
+};
+
+enum ColorKind {
+  BACKGROUND = 0,
+  TEXT,
+  DIMMED_TEXT,
+  URL,
+  NUM_KINDS
+};
+
+SkColor GetColor(ResultViewState state, ColorKind kind) {
+  static bool initialized = false;
+  static SkColor colors[NUM_STATES][NUM_KINDS];
+  if (!initialized) {
+    colors[NORMAL][BACKGROUND] = color_utils::GetSysSkColor(COLOR_WINDOW);
+    colors[SELECTED][BACKGROUND] = color_utils::GetSysSkColor(COLOR_HIGHLIGHT);
+    colors[NORMAL][TEXT] = color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
+    colors[SELECTED][TEXT] = color_utils::GetSysSkColor(COLOR_HIGHLIGHTTEXT);
+

[Peter Kasting, 2009/09/04 20:53:58]

Nit: No blank line here.

+    colors[HOVERED][BACKGROUND] =
+        color_utils::AlphaBlend(colors[SELECTED][BACKGROUND],
+                                colors[NORMAL][BACKGROUND], 64);
+    colors[HOVERED][TEXT] = colors[NORMAL][TEXT];
+    const SkColor kDarkURL = SkColorSetRGB(0, 128, 0);
+    const SkColor kLightURL = SkColorSetRGB(128, 255, 128);
+    for (int i = 0; i < NUM_STATES; ++i) {
+      colors[i][DIMMED_TEXT] =
+          color_utils::AlphaBlend(colors[i][TEXT], colors[i][BACKGROUND], 128);
+      colors[i][URL] = color_utils::PickMoreReadableColor(kDarkURL, kLightURL,
+          colors[i][BACKGROUND]);
+    }
+    initialized = true;
+  }
+
+  return colors[state][kind];
+}
+
+const SkAlpha kGlassPopupAlpha = 240;
+const SkAlpha kOpaquePopupAlpha = 255;
 // 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;
+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
 // kIconVerticalPadding.
-static const int kTextVerticalPadding = 3;
+const int kTextVerticalPadding = 3;
 // The padding at the left edge of the row, left of the icon.
-static const int kRowLeftPadding = 6;
+const int kRowLeftPadding = 6;
 // The padding on the right edge of the row, right of the text.
-static const int kRowRightPadding = 3;
+const int kRowRightPadding = 3;
 // The horizontal distance between the right edge of the icon and the left edge
 // of the text.
-static const int kIconTextSpacing = 9;
+const int kIconTextSpacing = 9;
 // The size delta between the font used for the edit and the result rows. Passed
 // to gfx::Font::DeriveFont.
-static const int kEditFontAdjust = -1;
+const int kEditFontAdjust = -1;
+
+}
 
 class AutocompleteResultView : public views::View {
  public:
   AutocompleteResultView(AutocompleteResultViewModel* model,
                          int model_index,
                          const gfx::Font& font);
   virtual ~AutocompleteResultView();
 
   // Updates the match used to paint the contents of this result view. We copy
   // the match so that we can continue to paint the last result even after the
   // model has changed.
   void set_match(const AutocompleteMatch& match) { match_ = match; }
 
   // Overridden from views::View:
   virtual void Paint(gfx::Canvas* canvas);
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   virtual void OnMouseEntered(const views::MouseEvent& event);
   virtual void OnMouseMoved(const views::MouseEvent& event);
   virtual void OnMouseExited(const views::MouseEvent& event);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
   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;
+  ResultViewState GetState() const;
 
   SkBitmap* GetIcon() const;
 
   // Draws the specified |text| into the canvas, using highlighting provided by
   // |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(gfx::Canvas* canvas,
                  const std::wstring& text,
                  const ACMatchClassifications& classifications,
@@ skipping 184 matching lines @@
       mirroring_context_(new MirroringContext()),
       match_(NULL, 0, false, AutocompleteMatch::URL_WHAT_YOU_TYPED) {
   CHECK(model_index >= 0);
   InitClass();
 }
 
 AutocompleteResultView::~AutocompleteResultView() {
 }
 
 void AutocompleteResultView::Paint(gfx::Canvas* canvas) {
-  canvas->FillRectInt(GetBackgroundColor(), 0, 0, width(), height());
+  const ResultViewState state = GetState();
+  if (state != NORMAL)
+    canvas->drawColor(GetColor(state, BACKGROUND));
 
   int x = MirroredLeftPointForRect(icon_bounds_);
 
   // Paint the icon.
   canvas->DrawBitmapInt(*GetIcon(), x, icon_bounds_.y());
 
   // Paint the text.
   // Initialize the |mirroring_context_| with the left and right positions.
   // The DrawString() function uses this |mirroring_context_| to calculate the
   // position of an input text.
@@ skipping 72 matching lines @@
   else if (event.IsOnlyLeftMouseButton())
     model_->OpenIndex(model_index_, CURRENT_TAB);
 }
 
 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 {
+ResultViewState AutocompleteResultView::GetState() const {
   if (model_->IsSelectedIndex(model_index_))
-    return kSelectedBackgroundColor;
-  return hot_ ? kHoverBackgroundColor : kBackgroundColor;
-}
-
-SkColor AutocompleteResultView::GetTextColor() const {
-  return model_->IsSelectedIndex(model_index_) ? kSelectedTextColor
-                                               : kTextColor;
+    return SELECTED;
+  return model_->IsHoveredIndex(model_index_) ? HOVERED : NORMAL;

[Peter Kasting, 2009/09/04 22:12:31]

For 3.0, you should change "model_->IsHoveredIndex(model_index_)" to "hot_".

 }
 
 SkBitmap* AutocompleteResultView::GetIcon() const {
   bool selected = model_->IsSelectedIndex(model_index_);
   if (match_.starred)
     return selected ? icon_star_selected_ : icon_star_;
   switch (match_.type) {
     case AutocompleteMatch::URL_WHAT_YOU_TYPED:
     case AutocompleteMatch::HISTORY_URL:
     case AutocompleteMatch::NAVSUGGEST:
@@ skipping 105 matching lines @@
                         string_width, display_font.height());
   return string_width;
 }
 
 gfx::Font AutocompleteResultView::GetFragmentFont(int style) const {
   return (style & ACMatchClassification::MATCH) ?
       font_.DeriveFont(0, gfx::Font::BOLD) : 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 selected ? kHighlightURLColor : kStandardURLColor;
-  }
-  if (style & ACMatchClassification::DIM)
-    return selected ? kSelectedDimTextColor : kDimTextColor;
-  return GetTextColor();
+  const ResultViewState state = GetState();
+  if (style & ACMatchClassification::URL)
+    return GetColor(state, URL);
+  return GetColor(state,
+      (style & ACMatchClassification::DIM) ? DIMMED_TEXT : TEXT);
 }
 
 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);
@@ skipping 275 matching lines @@
   //
   // 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::Canvas contents_canvas(width(), height(), true);
-  contents_canvas.FillRectInt(kBackgroundColor, 0, 0, width(), height());
+  contents_canvas.drawColor(GetColor(NORMAL, BACKGROUND));
   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);
@@ skipping 76 matching lines @@
   MakeContentsPath(&contents_path, contents_rect);
   ScopedGDIObject<HRGN> popup_region;
   popup_region.Set(contents_path.CreateHRGN());
   bb.hRgnBlur = popup_region.Get();
   DwmEnableBlurBehindWindow(GetWidget()->GetNativeView(), &bb);
 }
 
 void AutocompletePopupContentsView::MakeCanvasTransparent(
     gfx::Canvas* canvas) {
   // Allow the window blur effect to show through the popup background.
-  SkPaint paint;
-  SkColor transparency = GetThemeProvider()->ShouldUseNativeFrame() ?
-      kGlassPopupTransparency : kOpaquePopupTransparency;
-  paint.setColor(SkColorSetARGB(transparency, 255, 255, 255));
-  paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
-  paint.setStyle(SkPaint::kFill_Style);
-  canvas->FillRectInt(0, 0, canvas->getDevice()->width(),
-                      canvas->getDevice()->height(), paint);
+  SkAlpha alpha = GetThemeProvider()->ShouldUseNativeFrame() ?
+      kGlassPopupAlpha : kOpaquePopupAlpha;
+  canvas->drawColor(SkColorSetA(GetColor(NORMAL, BACKGROUND), alpha),
+                    SkXfermode::kDstIn_Mode);
 }