chrome/browser/profiles/profile_info_util.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 "chrome/browser/profiles/profile_info_util.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "third_party/skia/include/core/SkPaint.h"
   9 #include "third_party/skia/include/core/SkPath.h"
  10 #include "third_party/skia/include/core/SkScalar.h"
  11 #include "third_party/skia/include/core/SkXfermode.h"
  12 #include "ui/gfx/canvas.h"
  13 #include "ui/gfx/image/canvas_image_source.h"
  14 #include "ui/gfx/image/image_skia_operations.h"
  15
  16 namespace profiles {
  17
  18 const int kAvatarIconWidth = 38;
  19 const int kAvatarIconHeight = 31;
  20 const int kAvatarIconPadding = 2;
  21
  22 namespace internal {
  23
  24 // A CanvasImageSource that draws a sized and positioned avatar with an
  25 // optional border independently of the scale factor.
  26 class AvatarImageSource : public gfx::CanvasImageSource {
  27  public:
  28   enum AvatarPosition {
  29     POSITION_CENTER,
  30     POSITION_BOTTOM_CENTER,
  31   };
  32
  33   enum AvatarBorder {
  34     BORDER_NONE,
  35     BORDER_NORMAL,
  36     BORDER_ETCHED,
  37   };
  38
  39   AvatarImageSource(gfx::ImageSkia avatar,
  40                     const gfx::Size& canvas_size,
  41                     int size,
  42                     AvatarPosition position,
  43                     AvatarBorder border);
  44   virtual ~AvatarImageSource();
  45
  46   // CanvasImageSource override:
  47   virtual void Draw(gfx::Canvas* canvas) OVERRIDE;
  48
  49  private:
  50   gfx::ImageSkia avatar_;
  51   const gfx::Size canvas_size_;
  52   const int size_;
  53   const AvatarPosition position_;
  54   const AvatarBorder border_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(AvatarImageSource);
  57 };
  58
  59 AvatarImageSource::AvatarImageSource(gfx::ImageSkia avatar,
  60                                      const gfx::Size& canvas_size,
  61                                      int size,
  62                                      AvatarPosition position,
  63                                      AvatarBorder border)
  64     : gfx::CanvasImageSource(canvas_size, false),
  65       canvas_size_(canvas_size),
  66       size_(size - kAvatarIconPadding),
  67       position_(position),
  68       border_(border) {
  69   // Resize the avatar to the desired square size.
  70   avatar_ = gfx::ImageSkiaOperations::CreateResizedImage(
  71       avatar, skia::ImageOperations::RESIZE_BEST, gfx::Size(size_, size_));
  72 }
  73
  74 AvatarImageSource::~AvatarImageSource() {
  75 }
  76
  77 void AvatarImageSource::Draw(gfx::Canvas* canvas) {
  78   // Center the avatar horizontally.
  79   int x = (canvas_size_.width() - size_) / 2;
  80   int y;
  81
  82   if (position_ == POSITION_CENTER) {
  83     // Draw the avatar centered on the canvas.
  84     y = (canvas_size_.height() - size_) / 2;
  85   } else {
  86     // Draw the avatar on the bottom center of the canvas, leaving 1px below.
  87     y = canvas_size_.height() - size_ - 1;
  88   }
  89
  90   canvas->DrawImageInt(avatar_, x, y);
  91
  92   if (border_ == BORDER_NORMAL) {
  93     // Draw a gray border on the inside of the avatar.
  94     SkColor border_color = SkColorSetARGB(83, 0, 0, 0);
  95
  96     // Offset the rectangle by a half pixel so the border is drawn within the
  97     // appropriate pixels no matter the scale factor. Subtract 1 from the right
  98     // and bottom sizes to specify the endpoints, yielding -0.5.
  99     SkPath path;
 100     path.addRect(SkFloatToScalar(x + 0.5f),  // left
 101                  SkFloatToScalar(y + 0.5f),  // top
 102                  SkFloatToScalar(x + size_ - 0.5f),   // right
 103                  SkFloatToScalar(y + size_ - 0.5f));  // bottom
 104
 105     SkPaint paint;
 106     paint.setColor(border_color);
 107     paint.setStyle(SkPaint::kStroke_Style);
 108     paint.setStrokeWidth(SkIntToScalar(1));
 109
 110     canvas->DrawPath(path, paint);
 111   } else if (border_ == BORDER_ETCHED) {
 112     // Give the avatar an etched look by drawing a highlight on the bottom and
 113     // right edges.
 114     SkColor shadow_color = SkColorSetARGB(83, 0, 0, 0);
 115     SkColor highlight_color = SkColorSetARGB(96, 255, 255, 255);
 116
 117     SkPaint paint;
 118     paint.setStyle(SkPaint::kStroke_Style);
 119     paint.setStrokeWidth(SkIntToScalar(1));
 120
 121     SkPath path;
 122
 123     // Left and top shadows. To support higher scale factors than 1, position
 124     // the orthogonal dimension of each line on the half-pixel to separate the
 125     // pixel. For a vertical line, this means adding 0.5 to the x-value.
 126     path.moveTo(SkFloatToScalar(x + 0.5f), SkIntToScalar(y + size_));
 127
 128     // Draw up to the top-left. Stop with the y-value at a half-pixel.
 129     path.rLineTo(SkIntToScalar(0), SkFloatToScalar(-size_ + 0.5f));
 130
 131     // Draw right to the top-right, stopping within the last pixel.
 132     path.rLineTo(SkFloatToScalar(size_ - 0.5f), SkIntToScalar(0));
 133
 134     paint.setColor(shadow_color);
 135     canvas->DrawPath(path, paint);
 136
 137     path.reset();
 138
 139     // Bottom and right highlights. Note that the shadows own the shared corner
 140     // pixels, so reduce the sizes accordingly.
 141     path.moveTo(SkIntToScalar(x + 1), SkFloatToScalar(y + size_ - 0.5f));
 142
 143     // Draw right to the bottom-right.
 144     path.rLineTo(SkFloatToScalar(size_ - 1.5f), SkIntToScalar(0));
 145
 146     // Draw up to the top-right.
 147     path.rLineTo(SkIntToScalar(0), SkFloatToScalar(-size_ + 1.5f));
 148
 149     paint.setColor(highlight_color);
 150     canvas->DrawPath(path, paint);
 151   }
 152 }
 153
 154 }  // namespace internal
 155
 156 gfx::Image GetSizedAvatarIconWithBorder(const gfx::Image& image,
 157                                         bool is_rectangle,
 158                                         int width, int height) {
 159   if (!is_rectangle)
 160     return image;
 161
 162   gfx::Size size(width, height);
 163
 164   // Source for a centered, sized icon with a border.
 165   scoped_ptr<gfx::ImageSkiaSource> source(
 166       new internal::AvatarImageSource(
 167           *image.ToImageSkia(),
 168           size,
 169           std::min(width, height),
 170           internal::AvatarImageSource::POSITION_CENTER,
 171           internal::AvatarImageSource::BORDER_NORMAL));
 172
 173   return gfx::Image(gfx::ImageSkia(source.release(), size));
 174 }
 175
 176 gfx::Image GetAvatarIconForMenu(const gfx::Image& image,
 177                                 bool is_rectangle) {
 178   return GetSizedAvatarIconWithBorder(
 179       image, is_rectangle, kAvatarIconWidth, kAvatarIconHeight);
 180 }
 181
 182 gfx::Image GetAvatarIconForWebUI(const gfx::Image& image,
 183                                  bool is_rectangle) {
 184   if (!is_rectangle)
 185     return image;
 186
 187   gfx::Size size(kAvatarIconWidth, kAvatarIconHeight);
 188
 189   // Source for a centered, sized icon.
 190   scoped_ptr<gfx::ImageSkiaSource> source(
 191       new internal::AvatarImageSource(
 192           *image.ToImageSkia(),
 193           size,
 194           std::min(kAvatarIconWidth, kAvatarIconHeight),
 195           internal::AvatarImageSource::POSITION_CENTER,
 196           internal::AvatarImageSource::BORDER_NONE));
 197
 198   return gfx::Image(gfx::ImageSkia(source.release(), size));
 199 }
 200
 201 gfx::Image GetAvatarIconForTitleBar(const gfx::Image& image,
 202                                     bool is_rectangle,
 203                                     int dst_width,
 204                                     int dst_height) {
 205   if (!is_rectangle)
 206     return image;
 207
 208   int size = std::min(std::min(kAvatarIconWidth, kAvatarIconHeight),
 209                       std::min(dst_width, dst_height));
 210   gfx::Size dst_size(dst_width, dst_height);
 211
 212   // Source for a sized icon drawn at the bottom center of the canvas,
 213   // with an etched border.
 214   scoped_ptr<gfx::ImageSkiaSource> source(
 215       new internal::AvatarImageSource(
 216           *image.ToImageSkia(),
 217           dst_size,
 218           size,
 219           internal::AvatarImageSource::POSITION_BOTTOM_CENTER,
 220           internal::AvatarImageSource::BORDER_ETCHED));
 221
 222   return gfx::Image(gfx::ImageSkia(source.release(), dst_size));
 223 }
 224
 225 }  // namespace profiles