| OLD | NEW |
|---|
| (Empty) |
| 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/progress_bar.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/logging.h" | |
| 11 #include "third_party/skia/include/core/SkPaint.h" | |
| 12 #include "third_party/skia/include/core/SkXfermode.h" | |
| 13 #include "third_party/skia/include/effects/SkGradientShader.h" | |
| 14 #include "ui/accessibility/ax_view_state.h" | |
| 15 #include "ui/gfx/canvas.h" | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // Progress bar's border width. | |
| 20 const int kBorderWidth = 1; | |
| 21 | |
| 22 // Corner radius for the progress bar's border. | |
| 23 const int kCornerRadius = 2; | |
| 24 | |
| 25 // The width of the highlight at the right of the progress bar. | |
| 26 const int kHighlightWidth = 18; | |
| 27 | |
| 28 const SkColor kBackgroundColor = SkColorSetRGB(230, 230, 230); | |
| 29 const SkColor kBackgroundBorderColor = SkColorSetRGB(208, 208, 208); | |
| 30 const SkColor kBarBorderColor = SkColorSetRGB(65, 137, 237); | |
| 31 const SkColor kBarTopColor = SkColorSetRGB(110, 188, 249); | |
| 32 const SkColor kBarColorStart = SkColorSetRGB(86, 167, 247); | |
| 33 const SkColor kBarColorEnd = SkColorSetRGB(76, 148, 245); | |
| 34 const SkColor kBarHighlightEnd = SkColorSetRGB(114, 206, 251); | |
| 35 const SkColor kDisabledBarBorderColor = SkColorSetRGB(191, 191, 191); | |
| 36 const SkColor kDisabledBarColorStart = SkColorSetRGB(224, 224, 224); | |
| 37 const SkColor kDisabledBarColorEnd = SkColorSetRGB(212, 212, 212); | |
| 38 | |
| 39 void AddRoundRectPathWithPadding(int x, int y, | |
| 40 int w, int h, | |
| 41 int corner_radius, | |
| 42 SkScalar padding, | |
| 43 SkPath* path) { | |
| 44 DCHECK(path); | |
| 45 SkRect rect; | |
| 46 rect.set( | |
| 47 SkIntToScalar(x) + padding, SkIntToScalar(y) + padding, | |
| 48 SkIntToScalar(x + w) - padding, SkIntToScalar(y + h) - padding); | |
| 49 path->addRoundRect( | |
| 50 rect, | |
| 51 SkIntToScalar(corner_radius) - padding, | |
| 52 SkIntToScalar(corner_radius) - padding); | |
| 53 } | |
| 54 | |
| 55 void AddRoundRectPath(int x, int y, | |
| 56 int w, int h, | |
| 57 int corner_radius, | |
| 58 SkPath* path) { | |
| 59 AddRoundRectPathWithPadding(x, y, w, h, corner_radius, SK_ScalarHalf, path); | |
| 60 } | |
| 61 | |
| 62 void FillRoundRect(gfx::Canvas* canvas, | |
| 63 int x, int y, | |
| 64 int w, int h, | |
| 65 int corner_radius, | |
| 66 const SkColor colors[], | |
| 67 const SkScalar points[], | |
| 68 int count, | |
| 69 bool gradient_horizontal) { | |
| 70 SkPath path; | |
| 71 AddRoundRectPath(x, y, w, h, corner_radius, &path); | |
| 72 SkPaint paint; | |
| 73 paint.setStyle(SkPaint::kFill_Style); | |
| 74 paint.setFlags(SkPaint::kAntiAlias_Flag); | |
| 75 | |
| 76 SkPoint p[2]; | |
| 77 p[0].iset(x, y); | |
| 78 if (gradient_horizontal) { | |
| 79 p[1].iset(x + w, y); | |
| 80 } else { | |
| 81 p[1].iset(x, y + h); | |
| 82 } | |
| 83 skia::RefPtr<SkShader> s = skia::AdoptRef(SkGradientShader::CreateLinear( | |
| 84 p, colors, points, count, SkShader::kClamp_TileMode)); | |
| 85 paint.setShader(s.get()); | |
| 86 | |
| 87 canvas->DrawPath(path, paint); | |
| 88 } | |
| 89 | |
| 90 void FillRoundRect(gfx::Canvas* canvas, | |
| 91 int x, int y, | |
| 92 int w, int h, | |
| 93 int corner_radius, | |
| 94 SkColor gradient_start_color, | |
| 95 SkColor gradient_end_color, | |
| 96 bool gradient_horizontal) { | |
| 97 if (gradient_start_color != gradient_end_color) { | |
| 98 SkColor colors[2] = { gradient_start_color, gradient_end_color }; | |
| 99 FillRoundRect(canvas, x, y, w, h, corner_radius, | |
| 100 colors, NULL, 2, gradient_horizontal); | |
| 101 } else { | |
| 102 SkPath path; | |
| 103 AddRoundRectPath(x, y, w, h, corner_radius, &path); | |
| 104 SkPaint paint; | |
| 105 paint.setStyle(SkPaint::kFill_Style); | |
| 106 paint.setFlags(SkPaint::kAntiAlias_Flag); | |
| 107 paint.setColor(gradient_start_color); | |
| 108 canvas->DrawPath(path, paint); | |
| 109 } | |
| 110 } | |
| 111 | |
| 112 void StrokeRoundRect(gfx::Canvas* canvas, | |
| 113 int x, int y, | |
| 114 int w, int h, | |
| 115 int corner_radius, | |
| 116 SkColor stroke_color, | |
| 117 int stroke_width) { | |
| 118 SkPath path; | |
| 119 AddRoundRectPath(x, y, w, h, corner_radius, &path); | |
| 120 SkPaint paint; | |
| 121 paint.setShader(NULL); | |
| 122 paint.setColor(stroke_color); | |
| 123 paint.setStyle(SkPaint::kStroke_Style); | |
| 124 paint.setFlags(SkPaint::kAntiAlias_Flag); | |
| 125 paint.setStrokeWidth(SkIntToScalar(stroke_width)); | |
| 126 canvas->DrawPath(path, paint); | |
| 127 } | |
| 128 | |
| 129 } // namespace | |
| 130 | |
| 131 namespace views { | |
| 132 | |
| 133 // static | |
| 134 const char ProgressBar::kViewClassName[] = "ProgressBar"; | |
| 135 | |
| 136 ProgressBar::ProgressBar() | |
| 137 : min_display_value_(0.0), | |
| 138 max_display_value_(1.0), | |
| 139 current_value_(0.0) { | |
| 140 } | |
| 141 | |
| 142 ProgressBar::~ProgressBar() { | |
| 143 } | |
| 144 | |
| 145 double ProgressBar::GetNormalizedValue() const { | |
| 146 const double capped_value = std::min( | |
| 147 std::max(current_value_, min_display_value_), max_display_value_); | |
| 148 return (capped_value - min_display_value_) / | |
| 149 (max_display_value_ - min_display_value_); | |
| 150 } | |
| 151 | |
| 152 void ProgressBar::SetDisplayRange(double min_display_value, | |
| 153 double max_display_value) { | |
| 154 if (min_display_value != min_display_value_ || | |
| 155 max_display_value != max_display_value_) { | |
| 156 DCHECK(min_display_value < max_display_value); | |
| 157 min_display_value_ = min_display_value; | |
| 158 max_display_value_ = max_display_value; | |
| 159 SchedulePaint(); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 void ProgressBar::SetValue(double value) { | |
| 164 if (value != current_value_) { | |
| 165 current_value_ = value; | |
| 166 SchedulePaint(); | |
| 167 } | |
| 168 } | |
| 169 | |
| 170 void ProgressBar::SetTooltipText(const base::string16& tooltip_text) { | |
| 171 tooltip_text_ = tooltip_text; | |
| 172 } | |
| 173 | |
| 174 bool ProgressBar::GetTooltipText(const gfx::Point& p, | |
| 175 base::string16* tooltip) const { | |
| 176 DCHECK(tooltip); | |
| 177 *tooltip = tooltip_text_; | |
| 178 return !tooltip_text_.empty(); | |
| 179 } | |
| 180 | |
| 181 void ProgressBar::GetAccessibleState(ui::AXViewState* state) { | |
| 182 state->role = ui::AX_ROLE_PROGRESS_INDICATOR; | |
| 183 state->AddStateFlag(ui::AX_STATE_READ_ONLY); | |
| 184 } | |
| 185 | |
| 186 gfx::Size ProgressBar::GetPreferredSize() const { | |
| 187 gfx::Size pref_size(100, 11); | |
| 188 gfx::Insets insets = GetInsets(); | |
| 189 pref_size.Enlarge(insets.width(), insets.height()); | |
| 190 return pref_size; | |
| 191 } | |
| 192 | |
| 193 const char* ProgressBar::GetClassName() const { | |
| 194 return kViewClassName; | |
| 195 } | |
| 196 | |
| 197 void ProgressBar::OnPaint(gfx::Canvas* canvas) { | |
| 198 gfx::Rect content_bounds = GetContentsBounds(); | |
| 199 int bar_left = content_bounds.x(); | |
| 200 int bar_top = content_bounds.y(); | |
| 201 int bar_width = content_bounds.width(); | |
| 202 int bar_height = content_bounds.height(); | |
| 203 | |
| 204 const int progress_width = | |
| 205 static_cast<int>(bar_width * GetNormalizedValue() + 0.5); | |
| 206 | |
| 207 // Draw background. | |
| 208 FillRoundRect(canvas, | |
| 209 bar_left, bar_top, bar_width, bar_height, | |
| 210 kCornerRadius, | |
| 211 kBackgroundColor, kBackgroundColor, | |
| 212 false); | |
| 213 StrokeRoundRect(canvas, | |
| 214 bar_left, bar_top, | |
| 215 bar_width, bar_height, | |
| 216 kCornerRadius, | |
| 217 kBackgroundBorderColor, | |
| 218 kBorderWidth); | |
| 219 | |
| 220 if (progress_width > 1) { | |
| 221 // Draw inner if wide enough. | |
| 222 if (progress_width > kBorderWidth * 2) { | |
| 223 canvas->Save(); | |
| 224 | |
| 225 SkPath inner_path; | |
| 226 AddRoundRectPathWithPadding( | |
| 227 bar_left, bar_top, progress_width, bar_height, | |
| 228 kCornerRadius, | |
| 229 0, | |
| 230 &inner_path); | |
| 231 canvas->ClipPath(inner_path, false); | |
| 232 | |
| 233 const SkColor bar_colors[] = { | |
| 234 kBarTopColor, | |
| 235 kBarTopColor, | |
| 236 kBarColorStart, | |
| 237 kBarColorEnd, | |
| 238 kBarColorEnd, | |
| 239 }; | |
| 240 // We want a thin 1-pixel line for kBarTopColor. | |
| 241 SkScalar scalar_height = SkIntToScalar(bar_height); | |
| 242 SkScalar highlight_width = SkScalarDiv(SK_Scalar1, scalar_height); | |
| 243 SkScalar border_width = SkScalarDiv(SkIntToScalar(kBorderWidth), | |
| 244 scalar_height); | |
| 245 const SkScalar bar_points[] = { | |
| 246 0, | |
| 247 border_width, | |
| 248 border_width + highlight_width, | |
| 249 SK_Scalar1 - border_width, | |
| 250 SK_Scalar1, | |
| 251 }; | |
| 252 | |
| 253 const SkColor disabled_bar_colors[] = { | |
| 254 kDisabledBarColorStart, | |
| 255 kDisabledBarColorStart, | |
| 256 kDisabledBarColorEnd, | |
| 257 kDisabledBarColorEnd, | |
| 258 }; | |
| 259 | |
| 260 const SkScalar disabled_bar_points[] = { | |
| 261 0, | |
| 262 border_width, | |
| 263 SK_Scalar1 - border_width, | |
| 264 SK_Scalar1 | |
| 265 }; | |
| 266 | |
| 267 // Do not start from (kBorderWidth, kBorderWidth) because it makes gaps | |
| 268 // between the inner and the border. | |
| 269 FillRoundRect(canvas, | |
| 270 bar_left, bar_top, | |
| 271 progress_width, bar_height, | |
| 272 kCornerRadius, | |
| 273 enabled() ? bar_colors : disabled_bar_colors, | |
| 274 enabled() ? bar_points : disabled_bar_points, | |
| 275 enabled() ? arraysize(bar_colors) : | |
| 276 arraysize(disabled_bar_colors), | |
| 277 false); | |
| 278 | |
| 279 if (enabled()) { | |
| 280 // Draw the highlight to the right. | |
| 281 const SkColor highlight_colors[] = { | |
| 282 SkColorSetA(kBarHighlightEnd, 0), | |
| 283 kBarHighlightEnd, | |
| 284 kBarHighlightEnd, | |
| 285 }; | |
| 286 const SkScalar highlight_points[] = { | |
| 287 0, | |
| 288 SK_Scalar1 - SkScalarDiv(SkIntToScalar(kBorderWidth), scalar_height), | |
| 289 SK_Scalar1, | |
| 290 }; | |
| 291 SkPaint paint; | |
| 292 paint.setStyle(SkPaint::kFill_Style); | |
| 293 paint.setFlags(SkPaint::kAntiAlias_Flag); | |
| 294 | |
| 295 SkPoint p[2]; | |
| 296 int highlight_left = | |
| 297 std::max(0, progress_width - kHighlightWidth - kBorderWidth); | |
| 298 p[0].iset(highlight_left, 0); | |
| 299 p[1].iset(progress_width, 0); | |
| 300 skia::RefPtr<SkShader> s = | |
| 301 skia::AdoptRef(SkGradientShader::CreateLinear( | |
| 302 p, highlight_colors, highlight_points, | |
| 303 arraysize(highlight_colors), SkShader::kClamp_TileMode)); | |
| 304 paint.setShader(s.get()); | |
| 305 paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); | |
| 306 canvas->DrawRect(gfx::Rect(highlight_left, 0, | |
| 307 kHighlightWidth + kBorderWidth, bar_height), | |
| 308 paint); | |
| 309 } | |
| 310 | |
| 311 canvas->Restore(); | |
| 312 } | |
| 313 | |
| 314 // Draw bar stroke | |
| 315 StrokeRoundRect(canvas, | |
| 316 bar_left, bar_top, progress_width, bar_height, | |
| 317 kCornerRadius, | |
| 318 enabled() ? kBarBorderColor : kDisabledBarBorderColor, | |
| 319 kBorderWidth); | |
| 320 } | |
| 321 } | |
| 322 | |
| 323 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
