ui/wm/core/image_grid.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/wm/core/image_grid.h"
   6
   7 #include <algorithm>
   8
   9 #include "third_party/skia/include/core/SkColor.h"
  10 #include "third_party/skia/include/core/SkXfermode.h"
  11 #include "ui/compositor/dip_util.h"
  12 #include "ui/gfx/canvas.h"
  13 #include "ui/gfx/geometry/rect.h"
  14 #include "ui/gfx/geometry/rect_conversions.h"
  15 #include "ui/gfx/geometry/size.h"
  16 #include "ui/gfx/geometry/size_conversions.h"
  17 #include "ui/gfx/image/image.h"
  18 #include "ui/gfx/image/image_skia_operations.h"
  19 #include "ui/gfx/transform.h"
  20
  21 using std::max;
  22 using std::min;
  23
  24 namespace wm {
  25 namespace {
  26
  27 // Sets the scaling for the transform applied to a layer.  The left, top,
  28 // right and bottom layers are stretched to the height or width of the
  29 // center image.
  30
  31 void ScaleWidth(gfx::Size center, ui::Layer* layer, gfx::Transform& transform) {
  32   float layer_width = layer->bounds().width() * layer->device_scale_factor();
  33   float scale = static_cast<float>(center.width()) / layer_width;
  34   transform.Scale(scale, 1.0);
  35 }
  36
  37 void ScaleHeight(gfx::Size center,
  38                  ui::Layer* layer,
  39                  gfx::Transform& transform) {
  40   float layer_height = layer->bounds().height() * layer->device_scale_factor();
  41   float scale = static_cast<float>(center.height()) / layer_height;
  42   transform.Scale(1.0, scale);
  43 }
  44
  45 // Returns the dimensions of |image| if non-NULL or gfx::Size(0, 0) otherwise.
  46 gfx::Size GetImageSize(const gfx::Image* image) {
  47   return image ? gfx::Size(image->ToImageSkia()->width(),
  48                            image->ToImageSkia()->height())
  49                : gfx::Size();
  50 }
  51
  52 // Returns true if |layer|'s bounds don't fit within |size|.
  53 bool LayerExceedsSize(const ui::Layer* layer, const gfx::Size& size) {
  54   return layer->bounds().width() > size.width() ||
  55          layer->bounds().height() > size.height();
  56 }
  57
  58 }  // namespace
  59
  60 gfx::RectF ImageGrid::TestAPI::GetTransformedLayerBounds(
  61     const ui::Layer& layer) {
  62   gfx::RectF bounds = layer.bounds();
  63   layer.transform().TransformRect(&bounds);
  64   return bounds;
  65 }
  66
  67 ImageGrid::ImageGrid()
  68     : layer_(new ui::Layer(ui::LAYER_NOT_DRAWN)),
  69       top_image_height_(0),
  70       bottom_image_height_(0),
  71       left_image_width_(0),
  72       right_image_width_(0),
  73       base_top_row_height_(0),
  74       base_bottom_row_height_(0),
  75       base_left_column_width_(0),
  76       base_right_column_width_(0) {
  77 }
  78
  79 ImageGrid::~ImageGrid() {
  80 }
  81
  82 void ImageGrid::SetImages(const gfx::Image* top_left_image,
  83                           const gfx::Image* top_image,
  84                           const gfx::Image* top_right_image,
  85                           const gfx::Image* left_image,
  86                           const gfx::Image* center_image,
  87                           const gfx::Image* right_image,
  88                           const gfx::Image* bottom_left_image,
  89                           const gfx::Image* bottom_image,
  90                           const gfx::Image* bottom_right_image) {
  91   SetImage(top_left_image, &top_left_layer_, &top_left_painter_, NONE);
  92   SetImage(top_image, &top_layer_, &top_painter_, HORIZONTAL);
  93   SetImage(top_right_image, &top_right_layer_, &top_right_painter_, NONE);
  94   SetImage(left_image, &left_layer_, &left_painter_, VERTICAL);
  95   SetImage(center_image, &center_layer_, &center_painter_, NONE);
  96   SetImage(right_image, &right_layer_, &right_painter_, VERTICAL);
  97   SetImage(bottom_left_image, &bottom_left_layer_, &bottom_left_painter_, NONE);
  98   SetImage(bottom_image, &bottom_layer_, &bottom_painter_, HORIZONTAL);
  99   SetImage(
 100       bottom_right_image, &bottom_right_layer_, &bottom_right_painter_, NONE);
 101
 102   top_image_height_ = GetImageSize(top_image).height();
 103   bottom_image_height_ = GetImageSize(bottom_image).height();
 104   left_image_width_ = GetImageSize(left_image).width();
 105   right_image_width_ = GetImageSize(right_image).width();
 106
 107   base_top_row_height_ = max(GetImageSize(top_left_image).height(),
 108                              max(GetImageSize(top_image).height(),
 109                                  GetImageSize(top_right_image).height()));
 110   base_bottom_row_height_ = max(GetImageSize(bottom_left_image).height(),
 111                                 max(GetImageSize(bottom_image).height(),
 112                                     GetImageSize(bottom_right_image).height()));
 113   base_left_column_width_ = max(GetImageSize(top_left_image).width(),
 114                                 max(GetImageSize(left_image).width(),
 115                                     GetImageSize(bottom_left_image).width()));
 116   base_right_column_width_ = max(GetImageSize(top_right_image).width(),
 117                                  max(GetImageSize(right_image).width(),
 118                                      GetImageSize(bottom_right_image).width()));
 119
 120   // Invalidate previous |size_| so calls to SetSize() will recompute it.
 121   size_.SetSize(0, 0);
 122 }
 123
 124 void ImageGrid::SetSize(const gfx::Size& size) {
 125   if (size_ == size)
 126     return;
 127
 128   size_ = size;
 129
 130   gfx::Rect updated_bounds = layer_->bounds();
 131   updated_bounds.set_size(size);
 132   layer_->SetBounds(updated_bounds);
 133
 134   // Calculate the available amount of space for corner images on all sides of
 135   // the grid.  If the images don't fit, we need to clip them.
 136   const int left = min(base_left_column_width_, size_.width() / 2);
 137   const int right = min(base_right_column_width_, size_.width() - left);
 138   const int top = min(base_top_row_height_, size_.height() / 2);
 139   const int bottom = min(base_bottom_row_height_, size_.height() - top);
 140
 141   // The remaining space goes to the center image.
 142   int center_width = std::max(size.width() - left - right, 0);
 143   int center_height = std::max(size.height() - top - bottom, 0);
 144
 145   // At non-integer scale factors, the ratio of dimensions in DIP is not
 146   // necessarily the same as the ratio in physical pixels due to rounding.  Set
 147   // the transform on each of the layers based on dimensions in pixels.
 148   gfx::Size center_size_in_pixels = gfx::ToFlooredSize(gfx::ScaleSize(
 149       gfx::Size(center_width, center_height), layer_->device_scale_factor()));
 150
 151   if (top_layer_.get()) {
 152     if (center_width > 0) {
 153       gfx::Transform transform;
 154       transform.Translate(left, 0);
 155       ScaleWidth(center_size_in_pixels, top_layer_.get(), transform);
 156       top_layer_->SetTransform(transform);
 157     }
 158     top_layer_->SetVisible(center_width > 0);
 159   }
 160   if (bottom_layer_.get()) {
 161     if (center_width > 0) {
 162       gfx::Transform transform;
 163       transform.Translate(
 164           left, size.height() - bottom_layer_->bounds().height());
 165       ScaleWidth(center_size_in_pixels, bottom_layer_.get(), transform);
 166       bottom_layer_->SetTransform(transform);
 167     }
 168     bottom_layer_->SetVisible(center_width > 0);
 169   }
 170   if (left_layer_.get()) {
 171     if (center_height > 0) {
 172       gfx::Transform transform;
 173       transform.Translate(0, top);
 174       ScaleHeight(center_size_in_pixels, left_layer_.get(), transform);
 175       left_layer_->SetTransform(transform);
 176     }
 177     left_layer_->SetVisible(center_height > 0);
 178   }
 179   if (right_layer_.get()) {
 180     if (center_height > 0) {
 181       gfx::Transform transform;
 182       transform.Translate(
 183           size.width() - right_layer_->bounds().width(), top);
 184       ScaleHeight(center_size_in_pixels, right_layer_.get(), transform);
 185       right_layer_->SetTransform(transform);
 186     }
 187     right_layer_->SetVisible(center_height > 0);
 188   }
 189
 190   if (top_left_layer_.get()) {
 191     // No transformation needed; it should be at (0, 0) and unscaled.
 192     top_left_painter_->SetClipRect(
 193         LayerExceedsSize(top_left_layer_.get(), gfx::Size(left, top)) ?
 194             gfx::Rect(gfx::Rect(0, 0, left, top)) :
 195             gfx::Rect(),
 196         top_left_layer_.get());
 197   }
 198   if (top_right_layer_.get()) {
 199     gfx::Transform transform;
 200     transform.Translate(size.width() - top_right_layer_->bounds().width(), 0.0);
 201     top_right_layer_->SetTransform(transform);
 202     top_right_painter_->SetClipRect(
 203         LayerExceedsSize(top_right_layer_.get(), gfx::Size(right, top)) ?
 204             gfx::Rect(top_right_layer_->bounds().width() - right, 0,
 205                       right, top) :
 206             gfx::Rect(),
 207         top_right_layer_.get());
 208   }
 209   if (bottom_left_layer_.get()) {
 210     gfx::Transform transform;
 211     transform.Translate(
 212         0.0, size.height() - bottom_left_layer_->bounds().height());
 213     bottom_left_layer_->SetTransform(transform);
 214     bottom_left_painter_->SetClipRect(
 215         LayerExceedsSize(bottom_left_layer_.get(), gfx::Size(left, bottom)) ?
 216             gfx::Rect(0, bottom_left_layer_->bounds().height() - bottom,
 217                       left, bottom) :
 218             gfx::Rect(),
 219         bottom_left_layer_.get());
 220   }
 221   if (bottom_right_layer_.get()) {
 222     gfx::Transform transform;
 223     transform.Translate(
 224         size.width() - bottom_right_layer_->bounds().width(),
 225         size.height() - bottom_right_layer_->bounds().height());
 226     bottom_right_layer_->SetTransform(transform);
 227     bottom_right_painter_->SetClipRect(
 228         LayerExceedsSize(bottom_right_layer_.get(), gfx::Size(right, bottom)) ?
 229             gfx::Rect(bottom_right_layer_->bounds().width() - right,
 230                       bottom_right_layer_->bounds().height() - bottom,
 231                       right, bottom) :
 232             gfx::Rect(),
 233         bottom_right_layer_.get());
 234   }
 235
 236   if (center_layer_.get()) {
 237     if (center_width > 0 && center_height > 0) {
 238       gfx::Transform transform;
 239       transform.Translate(left, top);
 240       transform.Scale(center_width / center_layer_->bounds().width(),
 241                       center_height / center_layer_->bounds().height());
 242       center_layer_->SetTransform(transform);
 243     }
 244     center_layer_->SetVisible(center_width > 0 && center_height > 0);
 245   }
 246 }
 247
 248 void ImageGrid::SetContentBounds(const gfx::Rect& content_bounds) {
 249
 250   SetSize(gfx::Size(
 251       content_bounds.width() + left_image_width_ + right_image_width_,
 252       content_bounds.height() + top_image_height_ +
 253       bottom_image_height_));
 254   layer_->SetBounds(
 255       gfx::Rect(content_bounds.x() - left_image_width_,
 256                 content_bounds.y() - top_image_height_,
 257                 layer_->bounds().width(),
 258                 layer_->bounds().height()));
 259 }
 260
 261 void ImageGrid::ImagePainter::SetClipRect(const gfx::Rect& clip_rect,
 262                                           ui::Layer* layer) {
 263   if (clip_rect != clip_rect_) {
 264     clip_rect_ = clip_rect;
 265     layer->SchedulePaint(layer->bounds());
 266   }
 267 }
 268
 269 void ImageGrid::ImagePainter::OnPaintLayer(gfx::Canvas* canvas) {
 270   if (!clip_rect_.IsEmpty())
 271     canvas->ClipRect(clip_rect_);
 272   canvas->DrawImageInt(image_, 0, 0);
 273 }
 274
 275 void ImageGrid::ImagePainter::OnDelegatedFrameDamage(
 276     const gfx::Rect& damage_rect_in_dip) {
 277 }
 278
 279 void ImageGrid::ImagePainter::OnDeviceScaleFactorChanged(
 280     float device_scale_factor) {
 281   // Redrawing will take care of scale factor change.
 282 }
 283
 284 base::Closure ImageGrid::ImagePainter::PrepareForLayerBoundsChange() {
 285   return base::Closure();
 286 }
 287
 288 void ImageGrid::SetImage(const gfx::Image* image,
 289                          scoped_ptr<ui::Layer>* layer_ptr,
 290                          scoped_ptr<ImagePainter>* painter_ptr,
 291                          ImageType type) {
 292   // Minimum width (for HORIZONTAL) or height (for VERTICAL) of the
 293   // |image| so that layers are scaled property if the device scale
 294   // factor is non integral.
 295   const int kMinimumSize = 20;
 296
 297   // Clean out old layers and painters.
 298   if (layer_ptr->get())
 299     layer_->Remove(layer_ptr->get());
 300   layer_ptr->reset();
 301   painter_ptr->reset();
 302
 303   // If we're not using an image, we're done.
 304   if (!image)
 305     return;
 306
 307   gfx::ImageSkia image_skia = image->AsImageSkia();
 308   switch (type) {
 309     case HORIZONTAL:
 310       if (image_skia.width() < kMinimumSize) {
 311         image_skia = gfx::ImageSkiaOperations::CreateResizedImage(
 312             image_skia,
 313             skia::ImageOperations::RESIZE_GOOD,
 314             gfx::Size(kMinimumSize, image_skia.height()));
 315       }
 316       break;
 317     case VERTICAL:
 318       if (image_skia.height() < kMinimumSize) {
 319         image_skia = gfx::ImageSkiaOperations::CreateResizedImage(
 320             image_skia,
 321             skia::ImageOperations::RESIZE_GOOD,
 322             gfx::Size(image_skia.width(), kMinimumSize));
 323       }
 324       break;
 325     case NONE:
 326       break;
 327   }
 328
 329   // Set up the new layer and painter.
 330   layer_ptr->reset(new ui::Layer(ui::LAYER_TEXTURED));
 331
 332   const gfx::Size size = image_skia.size();
 333   layer_ptr->get()->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));
 334
 335   painter_ptr->reset(new ImagePainter(image_skia));
 336   layer_ptr->get()->set_delegate(painter_ptr->get());
 337   layer_ptr->get()->SetFillsBoundsOpaquely(false);
 338   layer_ptr->get()->SetVisible(true);
 339   layer_->Add(layer_ptr->get());
 340 }
 341
 342 }  // namespace wm