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