ui/views/painter.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/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/nine_image_painter.h"
  17 #include "ui/gfx/point.h"
  18 #include "ui/gfx/rect.h"
  19 #include "ui/views/view.h"
  20
  21 namespace views {
  22
  23 namespace {
  24
  25 // DashedFocusPainter ----------------------------------------------------------
  26
  27 class DashedFocusPainter : public Painter {
  28  public:
  29   explicit DashedFocusPainter(const gfx::Insets& insets);
  30   virtual ~DashedFocusPainter();
  31
  32   // Painter:
  33   virtual gfx::Size GetMinimumSize() const OVERRIDE;
  34   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
  35
  36  private:
  37   const gfx::Insets insets_;
  38
  39   DISALLOW_COPY_AND_ASSIGN(DashedFocusPainter);
  40 };
  41
  42 DashedFocusPainter::DashedFocusPainter(const gfx::Insets& insets)
  43     : insets_(insets) {
  44 }
  45
  46 DashedFocusPainter::~DashedFocusPainter() {
  47 }
  48
  49 gfx::Size DashedFocusPainter::GetMinimumSize() const {
  50   return gfx::Size();
  51 }
  52
  53 void DashedFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
  54   gfx::Rect rect(size);
  55   rect.Inset(insets_);
  56   canvas->DrawFocusRect(rect);
  57 }
  58
  59 // SolidFocusPainter -----------------------------------------------------------
  60
  61 class SolidFocusPainter : public Painter {
  62  public:
  63   SolidFocusPainter(SkColor color, const gfx::Insets& insets);
  64   virtual ~SolidFocusPainter();
  65
  66   // Painter:
  67   virtual gfx::Size GetMinimumSize() const OVERRIDE;
  68   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
  69
  70  private:
  71   const SkColor color_;
  72   const gfx::Insets insets_;
  73
  74   DISALLOW_COPY_AND_ASSIGN(SolidFocusPainter);
  75 };
  76
  77 SolidFocusPainter::SolidFocusPainter(SkColor color,
  78                                      const gfx::Insets& insets)
  79     : color_(color),
  80       insets_(insets) {
  81 }
  82
  83 SolidFocusPainter::~SolidFocusPainter() {
  84 }
  85
  86 gfx::Size SolidFocusPainter::GetMinimumSize() const {
  87   return gfx::Size();
  88 }
  89
  90 void SolidFocusPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
  91   gfx::Rect rect(size);
  92   rect.Inset(insets_);
  93   canvas->DrawSolidFocusRect(rect, color_);
  94 }
  95
  96 // GradientPainter ------------------------------------------------------------
  97
  98 class GradientPainter : public Painter {
  99  public:
 100   GradientPainter(bool horizontal,
 101                   SkColor* colors,
 102                   SkScalar* pos,
 103                   size_t count);
 104   virtual ~GradientPainter();
 105
 106   // Painter:
 107   virtual gfx::Size GetMinimumSize() const OVERRIDE;
 108   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
 109
 110  private:
 111   // If |horizontal_| is true then the gradient is painted horizontally.
 112   bool horizontal_;
 113   // The gradient colors.
 114   scoped_ptr<SkColor[]> colors_;
 115   // The relative positions of the corresponding gradient colors.
 116   scoped_ptr<SkScalar[]> pos_;
 117   // The number of elements in |colors_| and |pos_|.
 118   size_t count_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(GradientPainter);
 121 };
 122
 123 GradientPainter::GradientPainter(bool horizontal,
 124                                  SkColor* colors,
 125                                  SkScalar* pos,
 126                                  size_t count)
 127     : horizontal_(horizontal),
 128       colors_(new SkColor[count]),
 129       pos_(new SkScalar[count]),
 130       count_(count) {
 131   for (size_t i = 0; i < count_; ++i) {
 132     pos_[i] = pos[i];
 133     colors_[i] = colors[i];
 134   }
 135 }
 136
 137 GradientPainter::~GradientPainter() {
 138 }
 139
 140 gfx::Size GradientPainter::GetMinimumSize() const {
 141   return gfx::Size();
 142 }
 143
 144 void GradientPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
 145   SkPaint paint;
 146   SkPoint p[2];
 147   p[0].iset(0, 0);
 148   if (horizontal_)
 149     p[1].iset(size.width(), 0);
 150   else
 151     p[1].iset(0, size.height());
 152
 153   skia::RefPtr<SkShader> s = skia::AdoptRef(SkGradientShader::CreateLinear(
 154       p, colors_.get(), pos_.get(), count_, SkShader::kClamp_TileMode));
 155   paint.setStyle(SkPaint::kFill_Style);
 156   paint.setShader(s.get());
 157
 158   canvas->sk_canvas()->drawRectCoords(SkIntToScalar(0), SkIntToScalar(0),
 159                                       SkIntToScalar(size.width()),
 160                                       SkIntToScalar(size.height()), paint);
 161 }
 162
 163 // ImagePainter ---------------------------------------------------------------
 164
 165 // ImagePainter stores and paints nine images as a scalable grid.
 166 class VIEWS_EXPORT ImagePainter : public Painter {
 167  public:
 168   // Constructs an ImagePainter with the specified image resource ids.
 169   // See CreateImageGridPainter()'s comment regarding image ID count and order.
 170   explicit ImagePainter(const int image_ids[]);
 171
 172   // Constructs an ImagePainter with the specified image and insets.
 173   ImagePainter(const gfx::ImageSkia& image, const gfx::Insets& insets);
 174
 175   virtual ~ImagePainter();
 176
 177   // Painter:
 178   virtual gfx::Size GetMinimumSize() const OVERRIDE;
 179   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
 180
 181  private:
 182   scoped_ptr<gfx::NineImagePainter> nine_painter_;
 183
 184   DISALLOW_COPY_AND_ASSIGN(ImagePainter);
 185 };
 186
 187 ImagePainter::ImagePainter(const int image_ids[])
 188     : nine_painter_(ui::CreateNineImagePainter(image_ids)) {
 189 }
 190
 191 ImagePainter::ImagePainter(const gfx::ImageSkia& image,
 192                            const gfx::Insets& insets)
 193     : nine_painter_(new gfx::NineImagePainter(image, insets)) {
 194 }
 195
 196 ImagePainter::~ImagePainter() {
 197 }
 198
 199 gfx::Size ImagePainter::GetMinimumSize() const {
 200   return nine_painter_->GetMinimumSize();
 201 }
 202
 203 void ImagePainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
 204   nine_painter_->Paint(canvas, gfx::Rect(size));
 205 }
 206
 207 }  // namespace
 208
 209
 210 // Painter --------------------------------------------------------------------
 211
 212 Painter::Painter() {
 213 }
 214
 215 Painter::~Painter() {
 216 }
 217
 218 // static
 219 void Painter::PaintPainterAt(gfx::Canvas* canvas,
 220                              Painter* painter,
 221                              const gfx::Rect& rect) {
 222   DCHECK(canvas && painter);
 223   canvas->Save();
 224   canvas->Translate(rect.OffsetFromOrigin());
 225   painter->Paint(canvas, rect.size());
 226   canvas->Restore();
 227 }
 228
 229 // static
 230 void Painter::PaintFocusPainter(View* view,
 231                                 gfx::Canvas* canvas,
 232                                 Painter* focus_painter) {
 233   if (focus_painter && view->HasFocus())
 234     PaintPainterAt(canvas, focus_painter, view->GetLocalBounds());
 235 }
 236
 237 // static
 238 Painter* Painter::CreateHorizontalGradient(SkColor c1, SkColor c2) {
 239   SkColor colors[2];
 240   colors[0] = c1;
 241   colors[1] = c2;
 242   SkScalar pos[] = {0, 1};
 243   return new GradientPainter(true, colors, pos, 2);
 244 }
 245
 246 // static
 247 Painter* Painter::CreateVerticalGradient(SkColor c1, SkColor c2) {
 248   SkColor colors[2];
 249   colors[0] = c1;
 250   colors[1] = c2;
 251   SkScalar pos[] = {0, 1};
 252   return new GradientPainter(false, colors, pos, 2);
 253 }
 254
 255 // static
 256 Painter* Painter::CreateVerticalMultiColorGradient(SkColor* colors,
 257                                                    SkScalar* pos,
 258                                                    size_t count) {
 259   return new GradientPainter(false, colors, pos, count);
 260 }
 261
 262 // static
 263 Painter* Painter::CreateImagePainter(const gfx::ImageSkia& image,
 264                                      const gfx::Insets& insets) {
 265   return new ImagePainter(image, insets);
 266 }
 267
 268 // static
 269 Painter* Painter::CreateImageGridPainter(const int image_ids[]) {
 270   return new ImagePainter(image_ids);
 271 }
 272
 273 // static
 274 scoped_ptr<Painter> Painter::CreateDashedFocusPainter() {
 275   return scoped_ptr<Painter>(new DashedFocusPainter(gfx::Insets())).Pass();
 276 }
 277
 278 // static
 279 scoped_ptr<Painter> Painter::CreateDashedFocusPainterWithInsets(
 280     const gfx::Insets& insets) {
 281   return scoped_ptr<Painter>(new DashedFocusPainter(insets)).Pass();
 282 }
 283
 284 // static
 285 scoped_ptr<Painter> Painter::CreateSolidFocusPainter(
 286     SkColor color,
 287     const gfx::Insets& insets) {
 288   return scoped_ptr<Painter>(new SolidFocusPainter(color, insets)).Pass();
 289 }
 290
 291 // HorizontalPainter ----------------------------------------------------------
 292
 293 HorizontalPainter::HorizontalPainter(const int image_resource_names[]) {
 294   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 295   for (int i = 0; i < 3; ++i)
 296     images_[i] = rb.GetImageNamed(image_resource_names[i]).ToImageSkia();
 297   DCHECK_EQ(images_[LEFT]->height(), images_[CENTER]->height());
 298   DCHECK_EQ(images_[LEFT]->height(), images_[RIGHT]->height());
 299 }
 300
 301 HorizontalPainter::~HorizontalPainter() {
 302 }
 303
 304 gfx::Size HorizontalPainter::GetMinimumSize() const {
 305   return gfx::Size(
 306       images_[LEFT]->width() + images_[CENTER]->width() +
 307           images_[RIGHT]->width(), images_[LEFT]->height());
 308 }
 309
 310 void HorizontalPainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
 311   if (size.width() < GetMinimumSize().width())
 312     return;  // No room to paint.
 313
 314   canvas->DrawImageInt(*images_[LEFT], 0, 0);
 315   canvas->DrawImageInt(*images_[RIGHT], size.width() - images_[RIGHT]->width(),
 316                        0);
 317   canvas->TileImageInt(
 318       *images_[CENTER], images_[LEFT]->width(), 0,
 319       size.width() - images_[LEFT]->width() - images_[RIGHT]->width(),
 320       images_[LEFT]->height());
 321 }
 322
 323 }  // namespace views