ui/views/controls/slider.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/controls/slider.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14 #include "third_party/skia/include/core/SkColor.h"
  15 #include "third_party/skia/include/core/SkPaint.h"
  16 #include "ui/accessibility/ax_view_state.h"
  17 #include "ui/base/resource/resource_bundle.h"
  18 #include "ui/events/event.h"
  19 #include "ui/gfx/animation/slide_animation.h"
  20 #include "ui/gfx/canvas.h"
  21 #include "ui/gfx/point.h"
  22 #include "ui/gfx/rect.h"
  23 #include "ui/resources/grit/ui_resources.h"
  24 #include "ui/views/widget/widget.h"
  25
  26 namespace {
  27 const int kSlideValueChangeDurationMS = 150;
  28
  29 const int kBarImagesActive[] = {
  30     IDR_SLIDER_ACTIVE_LEFT,
  31     IDR_SLIDER_ACTIVE_CENTER,
  32     IDR_SLIDER_PRESSED_CENTER,
  33     IDR_SLIDER_PRESSED_RIGHT,
  34 };
  35
  36 const int kBarImagesDisabled[] = {
  37     IDR_SLIDER_DISABLED_LEFT,
  38     IDR_SLIDER_DISABLED_CENTER,
  39     IDR_SLIDER_DISABLED_CENTER,
  40     IDR_SLIDER_DISABLED_RIGHT,
  41 };
  42
  43 // The image chunks.
  44 enum BorderElements {
  45   LEFT,
  46   CENTER_LEFT,
  47   CENTER_RIGHT,
  48   RIGHT,
  49 };
  50 }  // namespace
  51
  52 namespace views {
  53
  54 Slider::Slider(SliderListener* listener, Orientation orientation)
  55     : listener_(listener),
  56       orientation_(orientation),
  57       value_(0.f),
  58       keyboard_increment_(0.1f),
  59       animating_value_(0.f),
  60       value_is_valid_(false),
  61       accessibility_events_enabled_(true),
  62       focus_border_color_(0),
  63       bar_active_images_(kBarImagesActive),
  64       bar_disabled_images_(kBarImagesDisabled) {
  65   EnableCanvasFlippingForRTLUI(true);
  66   SetFocusable(true);
  67   UpdateState(true);
  68 }
  69
  70 Slider::~Slider() {
  71 }
  72
  73 void Slider::SetValue(float value) {
  74   SetValueInternal(value, VALUE_CHANGED_BY_API);
  75 }
  76
  77 void Slider::SetKeyboardIncrement(float increment) {
  78   keyboard_increment_ = increment;
  79 }
  80
  81 void Slider::SetValueInternal(float value, SliderChangeReason reason) {
  82   bool old_value_valid = value_is_valid_;
  83
  84   value_is_valid_ = true;
  85   if (value < 0.0)
  86     value = 0.0;
  87   else if (value > 1.0)
  88     value = 1.0;
  89   if (value_ == value)
  90     return;
  91   float old_value = value_;
  92   value_ = value;
  93   if (listener_)
  94     listener_->SliderValueChanged(this, value_, old_value, reason);
  95
  96   if (old_value_valid && base::MessageLoop::current()) {
  97     // Do not animate when setting the value of the slider for the first time.
  98     // There is no message-loop when running tests. So we cannot animate then.
  99     animating_value_ = old_value;
 100     move_animation_.reset(new gfx::SlideAnimation(this));
 101     move_animation_->SetSlideDuration(kSlideValueChangeDurationMS);
 102     move_animation_->Show();
 103     AnimationProgressed(move_animation_.get());
 104   } else {
 105     SchedulePaint();
 106   }
 107   if (accessibility_events_enabled_ && GetWidget()) {
 108     NotifyAccessibilityEvent(
 109         ui::AX_EVENT_VALUE_CHANGED, true);
 110   }
 111 }
 112
 113 void Slider::PrepareForMove(const gfx::Point& point) {
 114   // Try to remember the position of the mouse cursor on the button.
 115   gfx::Insets inset = GetInsets();
 116   gfx::Rect content = GetContentsBounds();
 117   float value = move_animation_.get() && move_animation_->is_animating() ?
 118         animating_value_ : value_;
 119
 120   // For the horizontal orientation.
 121   const int thumb_x = value * (content.width() - thumb_->width());
 122   const int candidate_x = (base::i18n::IsRTL() ?
 123       width() - (point.x() - inset.left()) :
 124       point.x() - inset.left()) - thumb_x;
 125   if (candidate_x >= 0 && candidate_x < thumb_->width())
 126     initial_button_offset_.set_x(candidate_x);
 127   else
 128     initial_button_offset_.set_x(thumb_->width() / 2);
 129
 130   // For the vertical orientation.
 131   const int thumb_y = (1.0 - value) * (content.height() - thumb_->height());
 132   const int candidate_y = point.y() - thumb_y;
 133   if (candidate_y >= 0 && candidate_y < thumb_->height())
 134     initial_button_offset_.set_y(candidate_y);
 135   else
 136     initial_button_offset_.set_y(thumb_->height() / 2);
 137 }
 138
 139 void Slider::MoveButtonTo(const gfx::Point& point) {
 140   gfx::Insets inset = GetInsets();
 141   // Calculate the value.
 142   if (orientation_ == HORIZONTAL) {
 143     int amount = base::i18n::IsRTL() ?
 144         width() - inset.left() - point.x() - initial_button_offset_.x() :
 145         point.x() - inset.left() - initial_button_offset_.x();
 146     SetValueInternal(static_cast<float>(amount) /
 147                          (width() - inset.width() - thumb_->width()),
 148                      VALUE_CHANGED_BY_USER);
 149   } else {
 150     SetValueInternal(
 151         1.0f - static_cast<float>(point.y() - initial_button_offset_.y()) /
 152             (height() - thumb_->height()),
 153         VALUE_CHANGED_BY_USER);
 154   }
 155 }
 156
 157 void Slider::UpdateState(bool control_on) {
 158   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 159   if (control_on) {
 160     thumb_ = rb.GetImageNamed(IDR_SLIDER_ACTIVE_THUMB).ToImageSkia();
 161     for (int i = 0; i < 4; ++i)
 162       images_[i] = rb.GetImageNamed(bar_active_images_[i]).ToImageSkia();
 163   } else {
 164     thumb_ = rb.GetImageNamed(IDR_SLIDER_DISABLED_THUMB).ToImageSkia();
 165     for (int i = 0; i < 4; ++i)
 166       images_[i] = rb.GetImageNamed(bar_disabled_images_[i]).ToImageSkia();
 167   }
 168   bar_height_ = images_[LEFT]->height();
 169   SchedulePaint();
 170 }
 171
 172 void Slider::SetAccessibleName(const base::string16& name) {
 173   accessible_name_ = name;
 174 }
 175
 176 void Slider::OnPaintFocus(gfx::Canvas* canvas) {
 177   if (!HasFocus())
 178     return;
 179
 180   if (!focus_border_color_) {
 181     canvas->DrawFocusRect(GetLocalBounds());
 182   } else if (HasFocus()) {
 183     canvas->DrawSolidFocusRect(
 184         gfx::Rect(1, 1, width() - 3, height() - 3),
 185         focus_border_color_);
 186   }
 187 }
 188
 189 gfx::Size Slider::GetPreferredSize() const {
 190   const int kSizeMajor = 200;
 191   const int kSizeMinor = 40;
 192
 193   if (orientation_ == HORIZONTAL)
 194     return gfx::Size(std::max(width(), kSizeMajor), kSizeMinor);
 195   return gfx::Size(kSizeMinor, std::max(height(), kSizeMajor));
 196 }
 197
 198 void Slider::OnPaint(gfx::Canvas* canvas) {
 199   gfx::Rect content = GetContentsBounds();
 200   float value = move_animation_.get() && move_animation_->is_animating() ?
 201       animating_value_ : value_;
 202   if (orientation_ == HORIZONTAL) {
 203     // Paint slider bar with image resources.
 204
 205     // Inset the slider bar a little bit, so that the left or the right end of
 206     // the slider bar will not be exposed under the thumb button when the thumb
 207     // button slides to the left most or right most position.
 208     const int kBarInsetX = 2;
 209     int bar_width = content.width() - kBarInsetX * 2;
 210     int bar_cy = content.height() / 2 - bar_height_ / 2;
 211
 212     int w = content.width() - thumb_->width();
 213     int full = value * w;
 214     int middle = std::max(full, images_[LEFT]->width());
 215
 216     canvas->Save();
 217     canvas->Translate(gfx::Vector2d(kBarInsetX, bar_cy));
 218     canvas->DrawImageInt(*images_[LEFT], 0, 0);
 219     canvas->DrawImageInt(*images_[RIGHT],
 220                          bar_width - images_[RIGHT]->width(),
 221                          0);
 222     canvas->TileImageInt(*images_[CENTER_LEFT],
 223                          images_[LEFT]->width(),
 224                          0,
 225                          middle - images_[LEFT]->width(),
 226                          bar_height_);
 227     canvas->TileImageInt(*images_[CENTER_RIGHT],
 228                          middle,
 229                          0,
 230                          bar_width - middle - images_[RIGHT]->width(),
 231                          bar_height_);
 232     canvas->Restore();
 233
 234     // Paint slider thumb.
 235     int button_cx = content.x() + full;
 236     int thumb_y = content.height() / 2 - thumb_->height() / 2;
 237     canvas->DrawImageInt(*thumb_, button_cx, thumb_y);
 238   } else {
 239     // TODO(jennyz): draw vertical slider bar with resources.
 240     // TODO(sad): The painting code should use NativeTheme for various
 241     // platforms.
 242     const int kButtonRadius = thumb_->width() / 2;
 243     const int kLineThickness = bar_height_ / 2;
 244     const SkColor kFullColor = SkColorSetARGB(125, 0, 0, 0);
 245     const SkColor kEmptyColor = SkColorSetARGB(50, 0, 0, 0);
 246
 247     int h = content.height() - thumb_->height();
 248     int full = value * h;
 249     int empty = h - full;
 250     int x = content.width() / 2 - kLineThickness / 2;
 251     canvas->FillRect(gfx::Rect(x, content.y() + kButtonRadius,
 252                                kLineThickness, empty),
 253                      kEmptyColor);
 254     canvas->FillRect(gfx::Rect(x, content.y() + empty + 2 * kButtonRadius,
 255                                kLineThickness, full),
 256                      kFullColor);
 257
 258     // TODO(mtomasz): We draw a thumb here because so far it is the same
 259     // for horizontal and vertical orientations. If it is different, then
 260     // we will need a separate resource.
 261     int button_cy = content.y() + h - full;
 262     int thumb_x = content.width() / 2 - thumb_->width() / 2;
 263     canvas->DrawImageInt(*thumb_, thumb_x, button_cy);
 264   }
 265   View::OnPaint(canvas);
 266   OnPaintFocus(canvas);
 267 }
 268
 269 bool Slider::OnMousePressed(const ui::MouseEvent& event) {
 270   if (!event.IsOnlyLeftMouseButton())
 271     return false;
 272   OnSliderDragStarted();
 273   PrepareForMove(event.location());
 274   MoveButtonTo(event.location());
 275   return true;
 276 }
 277
 278 bool Slider::OnMouseDragged(const ui::MouseEvent& event) {
 279   MoveButtonTo(event.location());
 280   return true;
 281 }
 282
 283 void Slider::OnMouseReleased(const ui::MouseEvent& event) {
 284   OnSliderDragEnded();
 285 }
 286
 287 bool Slider::OnKeyPressed(const ui::KeyEvent& event) {
 288   if (orientation_ == HORIZONTAL) {
 289     if (event.key_code() == ui::VKEY_LEFT) {
 290       SetValueInternal(value_ - keyboard_increment_, VALUE_CHANGED_BY_USER);
 291       return true;
 292     } else if (event.key_code() == ui::VKEY_RIGHT) {
 293       SetValueInternal(value_ + keyboard_increment_, VALUE_CHANGED_BY_USER);
 294       return true;
 295     }
 296   } else {
 297     if (event.key_code() == ui::VKEY_DOWN) {
 298       SetValueInternal(value_ - keyboard_increment_, VALUE_CHANGED_BY_USER);
 299       return true;
 300     } else if (event.key_code() == ui::VKEY_UP) {
 301       SetValueInternal(value_ + keyboard_increment_, VALUE_CHANGED_BY_USER);
 302       return true;
 303     }
 304   }
 305   return false;
 306 }
 307
 308 void Slider::OnFocus() {
 309   View::OnFocus();
 310   SchedulePaint();
 311 }
 312
 313 void Slider::OnBlur() {
 314   View::OnBlur();
 315   SchedulePaint();
 316 }
 317
 318 void Slider::OnGestureEvent(ui::GestureEvent* event) {
 319   switch (event->type()) {
 320     // In a multi point gesture only the touch point will generate
 321     // an ET_GESTURE_TAP_DOWN event.
 322     case ui::ET_GESTURE_TAP_DOWN:
 323       OnSliderDragStarted();
 324       PrepareForMove(event->location());
 325       // Intentional fall through to next case.
 326     case ui::ET_GESTURE_SCROLL_BEGIN:
 327     case ui::ET_GESTURE_SCROLL_UPDATE:
 328       MoveButtonTo(event->location());
 329       event->SetHandled();
 330       break;
 331     case ui::ET_GESTURE_END:
 332       MoveButtonTo(event->location());
 333       event->SetHandled();
 334       if (event->details().touch_points() <= 1)
 335         OnSliderDragEnded();
 336       break;
 337     default:
 338       break;
 339   }
 340 }
 341
 342 void Slider::AnimationProgressed(const gfx::Animation* animation) {
 343   animating_value_ = animation->CurrentValueBetween(animating_value_, value_);
 344   SchedulePaint();
 345 }
 346
 347 void Slider::GetAccessibleState(ui::AXViewState* state) {
 348   state->role = ui::AX_ROLE_SLIDER;
 349   state->name = accessible_name_;
 350   state->value = base::UTF8ToUTF16(
 351       base::StringPrintf("%d%%", static_cast<int>(value_ * 100 + 0.5)));
 352 }
 353
 354 void Slider::OnSliderDragStarted() {
 355   if (listener_)
 356     listener_->SliderDragStarted(this);
 357 }
 358
 359 void Slider::OnSliderDragEnded() {
 360   if (listener_)
 361     listener_->SliderDragEnded(this);
 362 }
 363
 364 }  // namespace views