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/image/image.h"
14 #include "ui/gfx/image/image_skia_operations.h"
15 #include "ui/gfx/rect.h"
16 #include "ui/gfx/rect_conversions.h"
17 #include "ui/gfx/size.h"
18 #include "ui/gfx/size_conversions.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
ScaleWidth(gfx::Size center,ui::Layer * layer,gfx::Transform & transform)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
ScaleHeight(gfx::Size center,ui::Layer * layer,gfx::Transform & transform)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.
GetImageSize(const gfx::Image * image)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|.
LayerExceedsSize(const ui::Layer * layer,const gfx::Size & 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
GetTransformedLayerBounds(const ui::Layer & layer)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
ImageGrid()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
~ImageGrid()79 ImageGrid::~ImageGrid() {
80 }
81
SetImages(const gfx::Image * top_left_image,const gfx::Image * top_image,const gfx::Image * top_right_image,const gfx::Image * left_image,const gfx::Image * center_image,const gfx::Image * right_image,const gfx::Image * bottom_left_image,const gfx::Image * bottom_image,const gfx::Image * bottom_right_image)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, ¢er_layer_, ¢er_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
SetSize(const gfx::Size & size)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
SetContentBounds(const gfx::Rect & content_bounds)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
SetClipRect(const gfx::Rect & clip_rect,ui::Layer * layer)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
OnPaintLayer(gfx::Canvas * canvas)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
OnDeviceScaleFactorChanged(float device_scale_factor)275 void ImageGrid::ImagePainter::OnDeviceScaleFactorChanged(
276 float device_scale_factor) {
277 // Redrawing will take care of scale factor change.
278 }
279
PrepareForLayerBoundsChange()280 base::Closure ImageGrid::ImagePainter::PrepareForLayerBoundsChange() {
281 return base::Closure();
282 }
283
SetImage(const gfx::Image * image,scoped_ptr<ui::Layer> * layer_ptr,scoped_ptr<ImagePainter> * painter_ptr,ImageType type)284 void ImageGrid::SetImage(const gfx::Image* image,
285 scoped_ptr<ui::Layer>* layer_ptr,
286 scoped_ptr<ImagePainter>* painter_ptr,
287 ImageType type) {
288 // Minimum width (for HORIZONTAL) or height (for VERTICAL) of the
289 // |image| so that layers are scaled property if the device scale
290 // factor is non integral.
291 const int kMinimumSize = 20;
292
293 // Clean out old layers and painters.
294 if (layer_ptr->get())
295 layer_->Remove(layer_ptr->get());
296 layer_ptr->reset();
297 painter_ptr->reset();
298
299 // If we're not using an image, we're done.
300 if (!image)
301 return;
302
303 gfx::ImageSkia image_skia = image->AsImageSkia();
304 switch (type) {
305 case HORIZONTAL:
306 if (image_skia.width() < kMinimumSize) {
307 image_skia = gfx::ImageSkiaOperations::CreateResizedImage(
308 image_skia,
309 skia::ImageOperations::RESIZE_GOOD,
310 gfx::Size(kMinimumSize, image_skia.height()));
311 }
312 break;
313 case VERTICAL:
314 if (image_skia.height() < kMinimumSize) {
315 image_skia = gfx::ImageSkiaOperations::CreateResizedImage(
316 image_skia,
317 skia::ImageOperations::RESIZE_GOOD,
318 gfx::Size(image_skia.width(), kMinimumSize));
319 }
320 break;
321 case NONE:
322 break;
323 }
324
325 // Set up the new layer and painter.
326 layer_ptr->reset(new ui::Layer(ui::LAYER_TEXTURED));
327
328 const gfx::Size size = image_skia.size();
329 layer_ptr->get()->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));
330
331 painter_ptr->reset(new ImagePainter(image_skia));
332 layer_ptr->get()->set_delegate(painter_ptr->get());
333 layer_ptr->get()->SetFillsBoundsOpaquely(false);
334 layer_ptr->get()->SetVisible(true);
335 layer_->Add(layer_ptr->get());
336 }
337
338 } // namespace wm
339