aura: Draw drop shadows under browsers and menus.

ui/aura/image_grid.cc

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/aura/image_grid.h"
+
+#include <algorithm>
+
+#include "ui/aura/desktop.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/transform.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/skia/include/core/SkXfermode.h"
+
+using std::max;
+
+namespace aura {
+namespace internal {
+
+gfx::Rect ImageGrid::TestAPI::GetTransformedLayerBounds(
+    const ui::Layer& layer) {
+  gfx::Rect bounds = layer.bounds();
+  layer.transform().TransformRect(&bounds);
+  return bounds;
+}
+
+ImageGrid::ImageGrid()
+    : top_image_height_(0),
+      bottom_image_height_(0),
+      left_image_width_(0),
+      right_image_width_(0),
+      top_row_height_(0),
+      bottom_row_height_(0),
+      left_column_width_(0),
+      right_column_width_(0) {
+}
+
+ImageGrid::~ImageGrid() {
+}
+
+void ImageGrid::Init(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) {
+  layer_.reset(new ui::Layer(Desktop::GetInstance()->compositor(),
+                             ui::Layer::LAYER_HAS_NO_TEXTURE));
+
+  InitImage(top_left_image, &top_left_layer_, &top_left_painter_);
+  InitImage(top_image, &top_layer_, &top_painter_);
+  InitImage(top_right_image, &top_right_layer_, &top_right_painter_);
+  InitImage(left_image, &left_layer_, &left_painter_);
+  InitImage(center_image, &center_layer_, &center_painter_);
+  InitImage(right_image, &right_layer_, &right_painter_);
+  InitImage(bottom_left_image, &bottom_left_layer_, &bottom_left_painter_);
+  InitImage(bottom_image, &bottom_layer_, &bottom_painter_);
+  InitImage(bottom_right_image, &bottom_right_layer_, &bottom_right_painter_);
+
+  top_image_height_ = GetImageSize(top_image).height();
+  bottom_image_height_ = GetImageSize(bottom_image).height();
+  left_image_width_ = GetImageSize(left_image).width();
+  right_image_width_ = GetImageSize(right_image).width();
+
+  top_row_height_ = max(GetImageSize(top_left_image).height(),
+                        max(GetImageSize(top_image).height(),
+                            GetImageSize(top_right_image).height()));
+  bottom_row_height_ = max(GetImageSize(bottom_left_image).height(),
+                           max(GetImageSize(bottom_image).height(),
+                               GetImageSize(bottom_right_image).height()));
+  left_column_width_ = max(GetImageSize(top_left_image).width(),
+                           max(GetImageSize(left_image).width(),
+                               GetImageSize(bottom_left_image).width()));
+  right_column_width_ = max(GetImageSize(top_right_image).width(),
+                            max(GetImageSize(right_image).width(),
+                                GetImageSize(bottom_right_image).width()));
+}
+
+void ImageGrid::SetSize(const gfx::Size& size) {
+  if (size_ == size)
+    return;
+
+  size_ = size;
+
+  gfx::Rect updated_bounds = layer_->bounds();
+  updated_bounds.set_size(size);
+  layer_->SetBounds(updated_bounds);
+
+  float center_width = size.width() - left_column_width_ - right_column_width_;
+  float center_height = size.height() - top_row_height_ - bottom_row_height_;
+
+  if (top_layer_.get()) {
+    ui::Transform transform;
+    transform.SetScaleX(center_width / top_layer_->bounds().width());
+    transform.ConcatTranslate(left_column_width_, 0);
+    top_layer_->SetTransform(transform);
+  }
+  if (bottom_layer_.get()) {
+    ui::Transform transform;
+    transform.SetScaleX(center_width / bottom_layer_->bounds().width());
+    transform.ConcatTranslate(
+        left_column_width_, size.height() - bottom_layer_->bounds().height());
+    bottom_layer_->SetTransform(transform);
+  }
+  if (left_layer_.get()) {
+    ui::Transform transform;
+    transform.SetScaleY(center_height / left_layer_->bounds().height());
+    transform.ConcatTranslate(0, top_row_height_);
+    left_layer_->SetTransform(transform);
+  }
+  if (right_layer_.get()) {
+    ui::Transform transform;
+    transform.SetScaleY(center_height / right_layer_->bounds().height());
+    transform.ConcatTranslate(
+        size.width() - right_layer_->bounds().width(), top_row_height_);
+    right_layer_->SetTransform(transform);
+  }
+
+  if (top_left_layer_.get()) {
+    // No transformation needed; it should be at (0, 0) and unscaled.
+  }
+  if (top_right_layer_.get()) {
+    ui::Transform transform;
+    transform.SetTranslateX(size.width() - top_right_layer_->bounds().width());
+    top_right_layer_->SetTransform(transform);
+  }
+  if (bottom_left_layer_.get()) {
+    ui::Transform transform;
+    transform.SetTranslateY(
+        size.height() - bottom_left_layer_->bounds().height());
+    bottom_left_layer_->SetTransform(transform);
+  }
+  if (bottom_right_layer_.get()) {
+    ui::Transform transform;
+    transform.SetTranslate(
+        size.width() - bottom_right_layer_->bounds().width(),
+        size.height() - bottom_right_layer_->bounds().height());
+    bottom_right_layer_->SetTransform(transform);
+  }
+
+  if (center_layer_.get()) {
+    ui::Transform transform;
+    transform.SetScale(center_width / center_layer_->bounds().width(),
+                       center_height / center_layer_->bounds().height());
+    transform.ConcatTranslate(left_column_width_, top_row_height_);
+    center_layer_->SetTransform(transform);
+  }
+}
+
+void ImageGrid::ImagePainter::OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+  canvas->DrawBitmapInt(*(image_->ToSkBitmap()), 0, 0);
+}
+
+// static
+gfx::Size ImageGrid::GetImageSize(const gfx::Image* image) {
+  return image ?
+      gfx::Size(image->ToSkBitmap()->width(), image->ToSkBitmap()->height()) :
+      gfx::Size();
+}
+
+void ImageGrid::InitImage(const gfx::Image* image,
+                          scoped_ptr<ui::Layer>* layer_ptr,
+                          scoped_ptr<ImagePainter>* painter_ptr) {
+  if (!image)
+    return;
+
+  layer_ptr->reset(new ui::Layer(Desktop::GetInstance()->compositor(),
+                                 ui::Layer::LAYER_HAS_TEXTURE));
+
+  const gfx::Size size = GetImageSize(image);
+  layer_ptr->get()->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));
+
+  painter_ptr->reset(new ImagePainter(image));
+  layer_ptr->get()->set_delegate(painter_ptr->get());
+  layer_ptr->get()->SetFillsBoundsOpaquely(false);
+  layer_ptr->get()->SetVisible(true);
+  layer_->Add(layer_ptr->get());
+}
+
+}  // namespace internal
+}  // namespace aura