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/painter.h" 6 7 #include "base/logging.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "third_party/skia/include/effects/SkGradientShader.h" 10 #include "ui/base/resource/resource_bundle.h" 11 #include "ui/gfx/canvas.h" 12 #include "ui/gfx/image/image.h" 13 #include "ui/gfx/image/image_skia.h" 14 #include "ui/gfx/image/image_skia_operations.h" 15 #include "ui/gfx/insets.h" 16 #include "ui/gfx/point.h" 17 #include "ui/gfx/rect.h" 18 #include "ui/views/view.h" 19 20 namespace views { 21 22 namespace { 23 24 // DashedFocusPainter ---------------------------------------------------------- 25 26 class DashedFocusPainter : public Painter { 27 public: 28 explicit DashedFocusPainter(const gfx::Insets& insets); 29 virtual ~DashedFocusPainter(); 30 31 // Painter: 32 virtual gfx::Size GetMinimumSize() const OVERRIDE; 33 virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE; 34 35 private: 36 const gfx::Insets insets_; 37 38 DISALLOW_COPY_AND_ASSIGN(DashedFocusPainter); 39 }; 40 41 DashedFocusPainter::DashedFocusPainter(const gfx::Insets& insets) 42 : insets_(insets) { 43 } 44 45 DashedFocusPainter::~DashedFocusPainter() { 46 } 47 48 gfx::Size DashedFocusPainter::GetMinimumSize() const { 49 return gfx::Size(); 50 } 51 52 void DashedFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) { 53 gfx::Rect rect(size); 54 rect.Inset(insets_); 55 canvas->DrawFocusRect(rect); 56 } 57 58 // SolidFocusPainter ----------------------------------------------------------- 59 60 class SolidFocusPainter : public Painter { 61 public: 62 SolidFocusPainter(SkColor color, const gfx::Insets& insets); 63 virtual ~SolidFocusPainter(); 64 65 // Painter: 66 virtual gfx::Size GetMinimumSize() const OVERRIDE; 67 virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE; 68 69 private: 70 const SkColor color_; 71 const gfx::Insets insets_; 72 73 DISALLOW_COPY_AND_ASSIGN(SolidFocusPainter); 74 }; 75 76 SolidFocusPainter::SolidFocusPainter(SkColor color, 77 const gfx::Insets& insets) 78 : color_(color), 79 insets_(insets) { 80 } 81 82 SolidFocusPainter::~SolidFocusPainter() { 83 } 84 85 gfx::Size SolidFocusPainter::GetMinimumSize() const { 86 return gfx::Size(); 87 } 88 89 void SolidFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) { 90 gfx::Rect rect(size); 91 rect.Inset(insets_); 92 canvas->DrawSolidFocusRect(rect, color_); 93 } 94 95 // GradientPainter ------------------------------------------------------------ 96 97 class GradientPainter : public Painter { 98 public: 99 GradientPainter(bool horizontal, 100 SkColor* colors, 101 SkScalar* pos, 102 size_t count); 103 virtual ~GradientPainter(); 104 105 // Painter: 106 virtual gfx::Size GetMinimumSize() const OVERRIDE; 107 virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE; 108 109 private: 110 // If |horizontal_| is true then the gradient is painted horizontally. 111 bool horizontal_; 112 // The gradient colors. 113 scoped_ptr<SkColor[]> colors_; 114 // The relative positions of the corresponding gradient colors. 115 scoped_ptr<SkScalar[]> pos_; 116 // The number of elements in |colors_| and |pos_|. 117 size_t count_; 118 119 DISALLOW_COPY_AND_ASSIGN(GradientPainter); 120 }; 121 122 GradientPainter::GradientPainter(bool horizontal, 123 SkColor* colors, 124 SkScalar* pos, 125 size_t count) 126 : horizontal_(horizontal), 127 colors_(new SkColor[count]), 128 pos_(new SkScalar[count]), 129 count_(count) { 130 for (size_t i = 0; i < count_; ++i) { 131 pos_[i] = pos[i]; 132 colors_[i] = colors[i]; 133 } 134 } 135 136 GradientPainter::~GradientPainter() { 137 } 138 139 gfx::Size GradientPainter::GetMinimumSize() const { 140 return gfx::Size(); 141 } 142 143 void GradientPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) { 144 SkPaint paint; 145 SkPoint p[2]; 146 p[0].iset(0, 0); 147 if (horizontal_) 148 p[1].iset(size.width(), 0); 149 else 150 p[1].iset(0, size.height()); 151 152 skia::RefPtr<SkShader> s = skia::AdoptRef(SkGradientShader::CreateLinear( 153 p, colors_.get(), pos_.get(), count_, SkShader::kClamp_TileMode, NULL)); 154 paint.setStyle(SkPaint::kFill_Style); 155 paint.setShader(s.get()); 156 157 canvas->sk_canvas()->drawRectCoords(SkIntToScalar(0), SkIntToScalar(0), 158 SkIntToScalar(size.width()), 159 SkIntToScalar(size.height()), paint); 160 } 161 162 // ImagePainter --------------------------------------------------------------- 163 164 // ImagePainter stores and paints nine images as a scalable grid. 165 class VIEWS_EXPORT ImagePainter : public Painter { 166 public: 167 // Constructs an ImagePainter with the specified image resource ids. 168 // See CreateImageGridPainter()'s comment regarding image ID count and order. 169 explicit ImagePainter(const int image_ids[]); 170 171 // Constructs an ImagePainter with the specified image and insets. 172 ImagePainter(const gfx::ImageSkia& image, const gfx::Insets& insets); 173 174 virtual ~ImagePainter(); 175 176 // Returns true if the images are empty. 177 bool IsEmpty() const; 178 179 // Painter: 180 virtual gfx::Size GetMinimumSize() const OVERRIDE; 181 virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE; 182 183 private: 184 // Stretches the given image over the specified canvas area. 185 static void Fill(gfx::Canvas* c, 186 const gfx::ImageSkia& i, 187 int x, 188 int y, 189 int w, 190 int h); 191 192 // Images are numbered as depicted below. 193 // ____________________ 194 // |__i0__|__i1__|__i2__| 195 // |__i3__|__i4__|__i5__| 196 // |__i6__|__i7__|__i8__| 197 gfx::ImageSkia images_[9]; 198 199 DISALLOW_COPY_AND_ASSIGN(ImagePainter); 200 }; 201 202 ImagePainter::ImagePainter(const int image_ids[]) { 203 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); 204 for (size_t i = 0; i < 9; ++i) 205 if (image_ids[i] != 0) 206 images_[i] = *rb.GetImageSkiaNamed(image_ids[i]); 207 } 208 209 ImagePainter::ImagePainter(const gfx::ImageSkia& image, 210 const gfx::Insets& insets) { 211 DCHECK_GE(image.width(), insets.width()); 212 DCHECK_GE(image.height(), insets.height()); 213 214 // Extract subsets of the original image to match the |images_| format. 215 const int x[] = 216 { 0, insets.left(), image.width() - insets.right(), image.width() }; 217 const int y[] = 218 { 0, insets.top(), image.height() - insets.bottom(), image.height() }; 219 220 for (size_t j = 0; j < 3; ++j) { 221 for (size_t i = 0; i < 3; ++i) { 222 images_[i + j * 3] = gfx::ImageSkiaOperations::ExtractSubset(image, 223 gfx::Rect(x[i], y[j], x[i + 1] - x[i], y[j + 1] - y[j])); 224 } 225 } 226 } 227 228 ImagePainter::~ImagePainter() { 229 } 230 231 bool ImagePainter::IsEmpty() const { 232 return images_[0].isNull(); 233 } 234 235 gfx::Size ImagePainter::GetMinimumSize() const { 236 return IsEmpty() ? gfx::Size() : gfx::Size( 237 images_[0].width() + images_[1].width() + images_[2].width(), 238 images_[0].height() + images_[3].height() + images_[6].height()); 239 } 240 241 void ImagePainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) { 242 if (IsEmpty()) 243 return; 244 245 // In case the corners and edges don't all have the same width/height, we draw 246 // the center first, and extend it out in all directions to the edges of the 247 // images with the smallest widths/heights. This way there will be no 248 // unpainted areas, though some corners or edges might overlap the center. 249 int w = size.width(); 250 int i0w = images_[0].width(); 251 int i2w = images_[2].width(); 252 int i3w = images_[3].width(); 253 int i5w = images_[5].width(); 254 int i6w = images_[6].width(); 255 int i8w = images_[8].width(); 256 int i4x = std::min(std::min(i0w, i3w), i6w); 257 int i4w = w - i4x - std::min(std::min(i2w, i5w), i8w); 258 int h = size.height(); 259 int i0h = images_[0].height(); 260 int i1h = images_[1].height(); 261 int i2h = images_[2].height(); 262 int i6h = images_[6].height(); 263 int i7h = images_[7].height(); 264 int i8h = images_[8].height(); 265 int i4y = std::min(std::min(i0h, i1h), i2h); 266 int i4h = h - i4y - std::min(std::min(i6h, i7h), i8h); 267 if (!images_[4].isNull()) 268 Fill(canvas, images_[4], i4x, i4y, i4w, i4h); 269 canvas->DrawImageInt(images_[0], 0, 0); 270 Fill(canvas, images_[1], i0w, 0, w - i0w - i2w, i1h); 271 canvas->DrawImageInt(images_[2], w - i2w, 0); 272 Fill(canvas, images_[3], 0, i0h, i3w, h - i0h - i6h); 273 Fill(canvas, images_[5], w - i5w, i2h, i5w, h - i2h - i8h); 274 canvas->DrawImageInt(images_[6], 0, h - i6h); 275 Fill(canvas, images_[7], i6w, h - i7h, w - i6w - i8w, i7h); 276 canvas->DrawImageInt(images_[8], w - i8w, h - i8h); 277 } 278 279 // static 280 void ImagePainter::Fill(gfx::Canvas* c, 281 const gfx::ImageSkia& i, 282 int x, 283 int y, 284 int w, 285 int h) { 286 c->DrawImageInt(i, 0, 0, i.width(), i.height(), x, y, w, h, false); 287 } 288 289 } // namespace 290 291 292 // Painter -------------------------------------------------------------------- 293 294 Painter::Painter() { 295 } 296 297 Painter::~Painter() { 298 } 299 300 // static 301 void Painter::PaintPainterAt(gfx::Canvas* canvas, 302 Painter* painter, 303 const gfx::Rect& rect) { 304 DCHECK(canvas && painter); 305 canvas->Save(); 306 canvas->Translate(rect.OffsetFromOrigin()); 307 painter->Paint(canvas, rect.size()); 308 canvas->Restore(); 309 } 310 311 // static 312 void Painter::PaintFocusPainter(View* view, 313 gfx::Canvas* canvas, 314 Painter* focus_painter) { 315 if (focus_painter && view->HasFocus()) 316 PaintPainterAt(canvas, focus_painter, view->GetLocalBounds()); 317 } 318 319 // static 320 Painter* Painter::CreateHorizontalGradient(SkColor c1, SkColor c2) { 321 SkColor colors[2]; 322 colors[0] = c1; 323 colors[1] = c2; 324 SkScalar pos[] = {0, 1}; 325 return new GradientPainter(true, colors, pos, 2); 326 } 327 328 // static 329 Painter* Painter::CreateVerticalGradient(SkColor c1, SkColor c2) { 330 SkColor colors[2]; 331 colors[0] = c1; 332 colors[1] = c2; 333 SkScalar pos[] = {0, 1}; 334 return new GradientPainter(false, colors, pos, 2); 335 } 336 337 // static 338 Painter* Painter::CreateVerticalMultiColorGradient(SkColor* colors, 339 SkScalar* pos, 340 size_t count) { 341 return new GradientPainter(false, colors, pos, count); 342 } 343 344 // static 345 Painter* Painter::CreateImagePainter(const gfx::ImageSkia& image, 346 const gfx::Insets& insets) { 347 return new ImagePainter(image, insets); 348 } 349 350 // static 351 Painter* Painter::CreateImageGridPainter(const int image_ids[]) { 352 return new ImagePainter(image_ids); 353 } 354 355 // static 356 scoped_ptr<Painter> Painter::CreateDashedFocusPainter() { 357 return scoped_ptr<Painter>(new DashedFocusPainter(gfx::Insets())).Pass(); 358 } 359 360 // static 361 scoped_ptr<Painter> Painter::CreateDashedFocusPainterWithInsets( 362 const gfx::Insets& insets) { 363 return scoped_ptr<Painter>(new DashedFocusPainter(insets)).Pass(); 364 } 365 366 // static 367 scoped_ptr<Painter> Painter::CreateSolidFocusPainter( 368 SkColor color, 369 const gfx::Insets& insets) { 370 return scoped_ptr<Painter>(new SolidFocusPainter(color, insets)).Pass(); 371 } 372 373 // HorizontalPainter ---------------------------------------------------------- 374 375 HorizontalPainter::HorizontalPainter(const int image_resource_names[]) { 376 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); 377 for (int i = 0; i < 3; ++i) 378 images_[i] = rb.GetImageNamed(image_resource_names[i]).ToImageSkia(); 379 DCHECK_EQ(images_[LEFT]->height(), images_[CENTER]->height()); 380 DCHECK_EQ(images_[LEFT]->height(), images_[RIGHT]->height()); 381 } 382 383 HorizontalPainter::~HorizontalPainter() { 384 } 385 386 gfx::Size HorizontalPainter::GetMinimumSize() const { 387 return gfx::Size( 388 images_[LEFT]->width() + images_[CENTER]->width() + 389 images_[RIGHT]->width(), images_[LEFT]->height()); 390 } 391 392 void HorizontalPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) { 393 if (size.width() < GetMinimumSize().width()) 394 return; // No room to paint. 395 396 canvas->DrawImageInt(*images_[LEFT], 0, 0); 397 canvas->DrawImageInt(*images_[RIGHT], size.width() - images_[RIGHT]->width(), 398 0); 399 canvas->TileImageInt( 400 *images_[CENTER], images_[LEFT]->width(), 0, 401 size.width() - images_[LEFT]->width() - images_[RIGHT]->width(), 402 images_[LEFT]->height()); 403 } 404 405 } // namespace views 406
