Implement new slider control and disable the volume control when audio is muted.

ui/views/controls/slider.cc

 // Copyright (c) 2012 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 "ui/views/controls/slider.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/slide_animation.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 const int kSlideValueChangeDurationMS = 150;
+
+const int kBarImagesActive[] = {
+    IDR_SLIDER_ACTIVE_LEFT,
+    IDR_SLIDER_ACTIVE_CENTER,
+    IDR_SLIDER_PRESSED_CENTER,
+    IDR_SLIDER_PRESSED_RIGHT,
+};
+
+const int kBarImagesDisabled[] = {
+    IDR_SLIDER_DISABLED_LEFT,
+    IDR_SLIDER_DISABLED_CENTER,
+    IDR_SLIDER_DISABLED_CENTER,
+    IDR_SLIDER_DISABLED_RIGHT,
+};
+
+// The image chunks.
+enum BorderElements {
+  LEFT,
+  CENTER_LEFT,
+  CENTER_RIGHT,
+  RIGHT,
+};
 }
 
 namespace views {
 
 Slider::Slider(SliderListener* listener, Orientation orientation)
     : listener_(listener),
       orientation_(orientation),
       value_(0.f),
       keyboard_increment_(0.1f),
       animating_value_(0.f),
       value_is_valid_(false),
       accessibility_events_enabled_(true),
-      focus_border_color_(0) {
+      focus_border_color_(0),
+      bar_active_images_(kBarImagesActive),
+      bar_disabled_images_(kBarImagesDisabled) {
   EnableCanvasFlippingForRTLUI(true);
   set_focusable(true);
+  UpdateState(true);
 }
 
 Slider::~Slider() {
 }
 
 void Slider::SetValue(float value) {
   SetValueInternal(value, VALUE_CHANGED_BY_API);
 }
 
 void Slider::SetKeyboardIncrement(float increment) {
@@ skipping 38 matching lines @@
     int amount = base::i18n::IsRTL() ? width() - inset.left() - point.x() :
                                        point.x() - inset.left();
     SetValueInternal(static_cast<float>(amount) / (width() - inset.width()),
                      VALUE_CHANGED_BY_USER);
   } else {
     SetValueInternal(1.0f - static_cast<float>(point.y()) / height(),
                      VALUE_CHANGED_BY_USER);
   }
 }
 
+void Slider::UpdateState(bool control_on) {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  if (control_on) {
+    thumb_ = rb.GetImageNamed(IDR_SLIDER_ACTIVE_THUMB).ToImageSkia();
+    for (int i = 0; i < 4; ++i)
+      images_[i] = rb.GetImageNamed(bar_active_images_[i]).ToImageSkia();
+  } else {
+    thumb_ = rb.GetImageNamed(IDR_SLIDER_DISABLED_THUMB).ToImageSkia();
+    for (int i = 0; i < 4; ++i)
+      images_[i] = rb.GetImageNamed(bar_disabled_images_[i]).ToImageSkia();
+  }
+  bar_height_ = images_[LEFT]->height();
+  SchedulePaint();
+}
+
 void Slider::SetAccessibleName(const string16& name) {
   accessible_name_ = name;
 }
 
 gfx::Size Slider::GetPreferredSize() {
   const int kSizeMajor = 200;
   const int kSizeMinor = 40;
 
   if (orientation_ == HORIZONTAL)
     return gfx::Size(std::max(width(), kSizeMajor), kSizeMinor);
   return gfx::Size(kSizeMinor, std::max(height(), kSizeMajor));
 }
 
 void Slider::OnPaint(gfx::Canvas* canvas) {
-  // TODO(sad): The painting code should use NativeTheme for various platforms.
-  const int kButtonRadius = 5;
-  const int kLineThickness = 5;
-  const SkColor kFullColor = SkColorSetARGB(125, 0, 0, 0);
-  const SkColor kEmptyColor = SkColorSetARGB(50, 0, 0, 0);
-  const SkColor kButtonColor = SK_ColorBLACK;
-
   gfx::Rect content = GetContentsBounds();
   float value = move_animation_.get() && move_animation_->is_animating() ?
       animating_value_ : value_;
+  if (orientation_ == HORIZONTAL) {
+    // Paint slider bar with image resources.
 
-  int button_cx = 0, button_cy = 0;
-  if (orientation_ == HORIZONTAL) {
-    int w = content.width() - kButtonRadius * 2;
+    // Inset the slider bar a little bit, so that the left or the right end of
+    // the slider bar will not be exposed under the thumb button when the thumb
+    // button slides to the left most or right most position.
+    const int kBarInsetX = 2;
+    int bar_width = content.width() - kBarInsetX * 2;
+    int bar_cy = content.height() / 2 - bar_height_ / 2;
+
+    int w = content.width() - thumb_->width();
     int full = value * w;
-    int empty = w - full;
-    int y = content.height() / 2 - kLineThickness / 2;
-    canvas->FillRect(gfx::Rect(content.x() + kButtonRadius, y,
-                               full, kLineThickness),
-                     kFullColor);
-    canvas->FillRect(gfx::Rect(content.x() + full + 2 * kButtonRadius, y,
-                          std::max(0, empty - kButtonRadius), kLineThickness),
-                     kEmptyColor);
+    int middle = std::max(full, images_[LEFT]->width());
 
-    button_cx = content.x() + full + kButtonRadius;
-    button_cy = y + kLineThickness / 2;
+    canvas->Save();
+    canvas->Translate(gfx::Point(kBarInsetX, bar_cy));
+    canvas->DrawImageInt(*images_[LEFT], 0, 0);
+    canvas->DrawImageInt(*images_[RIGHT],
+                         bar_width - images_[RIGHT]->width(),
+                         0);
+    canvas->TileImageInt(*images_[CENTER_LEFT],
+                         images_[LEFT]->width(),
+                         0,
+                         middle - images_[LEFT]->width(),
+                         bar_height_);
+    canvas->TileImageInt(*images_[CENTER_RIGHT],
+                         middle,
+                         0,
+                         bar_width - middle - images_[RIGHT]->width(),
+                         bar_height_);
+    canvas->Restore();
+
+    // Paint slider thumb.
+    int button_cx = content.x() + full;
+    int thumb_y = content.height() / 2 - thumb_->height() / 2;
+    canvas->DrawImageInt(*thumb_, button_cx, thumb_y);
   } else {
+    // TODO(jennyz): draw vertical slider bar with resources.
+    // TODO(sad): The painting code should use NativeTheme for various
+    // platforms.
+    const int kButtonRadius = 5;
+    const int kLineThickness = 5;
+    const SkColor kFullColor = SkColorSetARGB(125, 0, 0, 0);
+    const SkColor kEmptyColor = SkColorSetARGB(50, 0, 0, 0);
+    const SkColor kButtonColor = SK_ColorBLACK;
+
+    int button_cx = 0, button_cy = 0;
     int h = content.height() - kButtonRadius * 2;
     int full = value * h;
     int empty = h - full;
     int x = content.width() / 2 - kLineThickness / 2;
     canvas->FillRect(gfx::Rect(x, content.y() + kButtonRadius,
                                kLineThickness, empty),
                      kEmptyColor);
     canvas->FillRect(gfx::Rect(x, content.y() + empty + 2 * kButtonRadius,
                                kLineThickness, full),
                      kFullColor);
 
     button_cx = x + kLineThickness / 2;
     button_cy = content.y() + empty + kButtonRadius;
+
+    SkPaint paint;
+    paint.setStyle(SkPaint::kFill_Style);
+    paint.setAntiAlias(true);
+    paint.setColor(kButtonColor);
+    canvas->sk_canvas()->drawCircle(button_cx, button_cy, kButtonRadius, paint);
+    View::OnPaint(canvas);
   }
-
-  SkPaint paint;
-  paint.setStyle(SkPaint::kFill_Style);
-  paint.setAntiAlias(true);
-  paint.setColor(kButtonColor);
-  canvas->sk_canvas()->drawCircle(button_cx, button_cy, kButtonRadius, paint);
-  View::OnPaint(canvas);
 }
 
 bool Slider::OnMousePressed(const views::MouseEvent& event) {
   if (listener_)
     listener_->SliderDragStarted(this);
   MoveButtonTo(event.location());
   return true;
 }
 
 bool Slider::OnMouseDragged(const views::MouseEvent& event) {
@@ skipping 53 matching lines @@
 void Slider::OnPaintFocusBorder(gfx::Canvas* canvas) {
   if (!focus_border_color_) {
     View::OnPaintFocusBorder(canvas);
   } else if (HasFocus() && (focusable() || IsAccessibilityFocusable())) {
     canvas->DrawRect(gfx::Rect(1, 1, width() - 3, height() - 3),
                      focus_border_color_);
   }
 }
 
 }  // namespace views