Make views::Label and views::Link auto-color themselves to be readable over their background colo...

views/controls/label.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.
 
 #include "views/controls/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/accessibility/accessible_view_state.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 "ui/gfx/font.h"
 #include "ui/gfx/insets.h"
 #include "views/background.h"
 
 namespace views {
 
-// The colors to use for enabled and disabled labels.
-static SkColor kEnabledColor;
-static SkColor kDisabledColor;
-
 // static
 const char Label::kViewClassName[] = "views/Label";
 
 const int Label::kFocusBorderPadding = 1;
 
 Label::Label() {
   Init(string16(), GetDefaultFont());
 }
 
 Label::Label(const string16& text) {
@@ skipping 32 matching lines @@
   url_set_ = true;
   text_size_valid_ = false;
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 const GURL Label::GetURL() const {
   return url_set_ ? url_ : GURL(UTF16ToUTF8(text_));
 }
 
-void Label::SetColor(const SkColor& color) {
-  color_ = color;
+void Label::SetAutoColorReadabilityEnabled(bool enabled) {
+  auto_color_readability_ = enabled;
+  RecalculateColors();
 }
 
-SkColor Label::GetColor() const {
-  return color_;
+void Label::SetEnabledColor(const SkColor& color) {
+  requested_enabled_color_ = color;
+  RecalculateColors();
 }
 
-void Label::MakeReadableOverBackgroundColor(const SkColor& background_color) {
-  SetColor(color_utils::GetReadableColor(
-      IsEnabled() ? kEnabledColor : kDisabledColor, background_color));
+void Label::SetDisabledColor(const SkColor& color) {
+  requested_disabled_color_ = color;
+  RecalculateColors();
+}
+
+void Label::SetBackgroundColor(const SkColor& color) {
+  background_color_ = color;
+  RecalculateColors();
 }
 
 void Label::SetHorizontalAlignment(Alignment alignment) {
   // If the View's UI layout is right-to-left and rtl_alignment_mode_ is
   // USE_UI_ALIGNMENT, we need to flip the alignment so that the alignment
   // settings take into account the text directionality.
   if (base::i18n::IsRTL() && (rtl_alignment_mode_ == USE_UI_ALIGNMENT) &&
       (alignment != ALIGN_CENTER))
     alignment = (alignment == ALIGN_LEFT) ? ALIGN_RIGHT : ALIGN_LEFT;
   if (horiz_alignment_ != alignment) {
@@ skipping 104 matching lines @@
   if (!is_multi_line_)
     return View::GetHeightForWidth(w);
 
   w = std::max(0, w - GetInsets().width());
   int h = font_.GetHeight();
   gfx::CanvasSkia::SizeStringInt(text_, font_, &w, &h,
                                  ComputeMultiLineFlags());
   return h + GetInsets().height();
 }
 
-void Label::OnEnabledChanged() {
-  View::OnEnabledChanged();
-  SetColor(IsEnabled() ? kEnabledColor : kDisabledColor);
-}
-
 std::string Label::GetClassName() const {
   return kViewClassName;
 }
 
 bool Label::HitTest(const gfx::Point& l) const {
   return false;
 }
 
 void Label::OnMouseMoved(const MouseEvent& event) {
   UpdateContainsMouse(event);
@@ skipping 28 matching lines @@
 void Label::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_STATICTEXT;
   state->state = ui::AccessibilityTypes::STATE_READONLY;
   state->name = text_;
 }
 
 void Label::PaintText(gfx::Canvas* canvas,
                       const string16& text,
                       const gfx::Rect& text_bounds,
                       int flags) {
-  canvas->DrawStringInt(text, font_, color_,
-                        text_bounds.x(), text_bounds.y(),
-                        text_bounds.width(), text_bounds.height(), flags);
+  canvas->DrawStringInt(text, font_,
+      IsEnabled() ? actual_enabled_color_ : actual_disabled_color_,
+      text_bounds.x(), text_bounds.y(), text_bounds.width(),
+      text_bounds.height(), flags);
 
   if (HasFocus() || paint_as_focused_) {
     gfx::Rect focus_bounds = text_bounds;
     focus_bounds.Inset(-kFocusBorderPadding, -kFocusBorderPadding);
     canvas->DrawFocusRect(focus_bounds.x(), focus_bounds.y(),
                           focus_bounds.width(), focus_bounds.height());
   }
 }
 
 gfx::Size Label::GetTextSize() const {
@@ skipping 40 matching lines @@
     bg->Paint(canvas, this);
 }
 
 // static
 gfx::Font Label::GetDefaultFont() {
   return ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont);
 }
 
 void Label::Init(const string16& text, const gfx::Font& font) {
   static bool initialized = false;
+  static SkColor kDefaultEnabledColor;
+  static SkColor kDefaultDisabledColor;
+  static SkColor kDefaultBackgroundColor;
   if (!initialized) {
 #if defined(OS_WIN)
-    kEnabledColor = color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
-    kDisabledColor = color_utils::GetSysSkColor(COLOR_GRAYTEXT);
+    kDefaultEnabledColor = color_utils::GetSysSkColor(COLOR_WINDOWTEXT);
+    kDefaultDisabledColor = color_utils::GetSysSkColor(COLOR_GRAYTEXT);
+    kDefaultBackgroundColor = color_utils::GetSysSkColor(COLOR_WINDOW);
 #else
     // TODO(beng): source from theme provider.
-    kEnabledColor = SK_ColorBLACK;
-    kDisabledColor = SK_ColorGRAY;
+    kDefaultEnabledColor = SK_ColorBLACK;
+    kDefaultDisabledColor = SK_ColorGRAY;
+    kDefaultBackgroundColor = SK_ColorWHITE;
 #endif
 
     initialized = true;
   }
 
   contains_mouse_ = false;
   font_ = font;
   text_size_valid_ = false;
-  SetText(text);
   url_set_ = false;
-  color_ = kEnabledColor;
+  requested_enabled_color_ = kDefaultEnabledColor;
+  requested_disabled_color_ = kDefaultDisabledColor;
+  background_color_ = kDefaultBackgroundColor;
+  auto_color_readability_ = true;
+  RecalculateColors();
   horiz_alignment_ = ALIGN_CENTER;
   is_multi_line_ = false;
   allow_character_break_ = false;
   elide_in_middle_ = false;
   collapse_when_hidden_ = false;
   rtl_alignment_mode_ = USE_UI_ALIGNMENT;
   paint_as_focused_ = false;
   has_focus_border_ = false;
+
+  SetText(text);
+}
+
+void Label::RecalculateColors() {
+  actual_enabled_color_ = auto_color_readability_ ?
+      color_utils::GetReadableColor(requested_enabled_color_,
+                                    background_color_) :
+      requested_enabled_color_;
+  actual_disabled_color_ = auto_color_readability_ ?
+      color_utils::GetReadableColor(requested_disabled_color_,
+                                    background_color_) :
+      requested_disabled_color_;
 }
 
 void Label::UpdateContainsMouse(const MouseEvent& event) {
   SetContainsMouse(GetTextBounds().Contains(event.x(), event.y()));
 }
 
 void Label::SetContainsMouse(bool contains_mouse) {
   if (contains_mouse_ == contains_mouse)
     return;
   contains_mouse_ = contains_mouse;
@@ skipping 103 matching lines @@
   // it is right aligned. Otherwise, its directionality is forced to be LTR.
   if (rtl_alignment_mode_ == AUTO_DETECT_ALIGNMENT) {
     if (horiz_alignment_ == ALIGN_RIGHT)
       *flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
     else
       *flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
   }
 }
 
 }  // namespace views