desktop_background_view.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6 
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 "ash/desktop_background/desktop_background_view.h"
6
7#include <limits>
8
9#include "ash/ash_export.h"
10#include "ash/desktop_background/desktop_background_controller.h"
11#include "ash/desktop_background/desktop_background_widget_controller.h"
12#include "ash/desktop_background/user_wallpaper_delegate.h"
13#include "ash/display/display_manager.h"
14#include "ash/root_window_controller.h"
15#include "ash/session_state_delegate.h"
16#include "ash/shell.h"
17#include "ash/shell_window_ids.h"
18#include "ash/wm/window_animations.h"
19#include "base/message_loop/message_loop.h"
20#include "base/strings/utf_string_conversions.h"
21#include "ui/aura/root_window.h"
22#include "ui/base/resource/resource_bundle.h"
23#include "ui/compositor/layer.h"
24#include "ui/gfx/canvas.h"
25#include "ui/gfx/image/image.h"
26#include "ui/gfx/size_conversions.h"
27#include "ui/gfx/transform.h"
28#include "ui/views/widget/widget.h"
29
30namespace ash {
31namespace internal {
32namespace {
33
34// For our scaling ratios we need to round positive numbers.
35int RoundPositive(double x) {
36  return static_cast<int>(floor(x + 0.5));
37}
38
39// A view that controls the child view's layer so that the layer
40// always has the same size as the display's original, un-scaled size
41// in DIP. The layer then transformed to fit to the virtual screen
42// size when laid-out.
43// This is to avoid scaling the image at painting time, then scaling
44// it back to the screen size in the compositor.
45class LayerControlView : public views::View {
46 public:
47  explicit LayerControlView(views::View* view) {
48    AddChildView(view);
49    view->SetPaintToLayer(true);
50  }
51
52  // Overrides views::View.
53  virtual void Layout() OVERRIDE {
54    gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
55        GetWidget()->GetNativeView());
56    DisplayManager* display_manager = Shell::GetInstance()->display_manager();
57    DisplayInfo info = display_manager->GetDisplayInfo(display.id());
58
59    gfx::SizeF pixel_size = display.size();
60    pixel_size.Scale(1.0f / info.ui_scale());
61    gfx::Size rounded_size = gfx::ToCeiledSize(pixel_size);
62    DCHECK_EQ(1, child_count());
63    views::View* child = child_at(0);
64    child->SetBounds(0, 0, rounded_size.width(), rounded_size.height());
65    gfx::Transform transform;
66    transform.Scale(info.ui_scale(), info.ui_scale());
67    child->SetTransform(transform);
68  }
69
70 private:
71  DISALLOW_COPY_AND_ASSIGN(LayerControlView);
72};
73
74}  // namespace
75
76////////////////////////////////////////////////////////////////////////////////
77// DesktopBackgroundView, public:
78
79DesktopBackgroundView::DesktopBackgroundView() {
80  set_context_menu_controller(this);
81}
82
83DesktopBackgroundView::~DesktopBackgroundView() {
84}
85
86////////////////////////////////////////////////////////////////////////////////
87// DesktopBackgroundView, views::View overrides:
88
89void DesktopBackgroundView::OnPaint(gfx::Canvas* canvas) {
90  // Scale the image while maintaining the aspect ratio, cropping as
91  // necessary to fill the background. Ideally the image should be larger
92  // than the largest display supported, if not we will center it rather than
93  // streching to avoid upsampling artifacts (Note that we could tile too, but
94  // decided not to do this at the moment).
95  DesktopBackgroundController* controller =
96      Shell::GetInstance()->desktop_background_controller();
97  gfx::ImageSkia wallpaper = controller->GetWallpaper();
98  WallpaperLayout wallpaper_layout = controller->GetWallpaperLayout();
99
100  gfx::NativeView native_view = GetWidget()->GetNativeView();
101  gfx::Display display = gfx::Screen::GetScreenFor(native_view)->
102      GetDisplayNearestWindow(native_view);
103
104  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
105  DisplayInfo display_info = display_manager->GetDisplayInfo(display.id());
106  float scaling = display_info.ui_scale();
107  if (scaling <= 1.0f)
108    scaling = 1.0f;
109  // Allow scaling up to the UI scaling.
110  // TODO(oshima): Create separate layer that fits to the image and then
111  // scale to avoid artifacts and be more efficient when clipped.
112  gfx::Rect wallpaper_rect(
113      0, 0, wallpaper.width() * scaling, wallpaper.height() * scaling);
114
115  if (wallpaper_layout == WALLPAPER_LAYOUT_CENTER_CROPPED &&
116      wallpaper_rect.width() >= width() &&
117      wallpaper_rect.height() >= height()) {
118    // The dimension with the smallest ratio must be cropped, the other one
119    // is preserved. Both are set in gfx::Size cropped_size.
120    double horizontal_ratio = static_cast<double>(width()) /
121        static_cast<double>(wallpaper.width());
122    double vertical_ratio = static_cast<double>(height()) /
123        static_cast<double>(wallpaper.height());
124
125    gfx::Size cropped_size;
126    if (vertical_ratio > horizontal_ratio) {
127      cropped_size = gfx::Size(
128          RoundPositive(static_cast<double>(width()) / vertical_ratio),
129          wallpaper.height());
130    } else {
131      cropped_size = gfx::Size(wallpaper.width(),
132          RoundPositive(static_cast<double>(height()) / horizontal_ratio));
133    }
134
135    gfx::Rect wallpaper_cropped_rect(
136        0, 0, wallpaper.width(), wallpaper.height());
137    wallpaper_cropped_rect.ClampToCenteredSize(cropped_size);
138    canvas->DrawImageInt(wallpaper,
139        wallpaper_cropped_rect.x(), wallpaper_cropped_rect.y(),
140        wallpaper_cropped_rect.width(), wallpaper_cropped_rect.height(),
141        0, 0, width(), height(),
142        true);
143  } else if (wallpaper_layout == WALLPAPER_LAYOUT_TILE) {
144    canvas->TileImageInt(wallpaper, 0, 0, width(), height());
145  } else if (wallpaper_layout == WALLPAPER_LAYOUT_STRETCH) {
146    // This is generally not recommended as it may show artifacts.
147    canvas->DrawImageInt(wallpaper, 0, 0, wallpaper.width(),
148        wallpaper.height(), 0, 0, width(), height(), true);
149  } else {
150    // Fill with black to make sure that the entire area is opaque.
151    canvas->FillRect(GetLocalBounds(), SK_ColorBLACK);
152    // All other are simply centered, and not scaled (but may be clipped).
153    if (wallpaper.width() && wallpaper.height()) {
154      canvas->DrawImageInt(
155          wallpaper,
156          0, 0, wallpaper.width(), wallpaper.height(),
157          (width() - wallpaper_rect.width()) / 2,
158          (height() - wallpaper_rect.height()) / 2,
159          wallpaper_rect.width(),
160          wallpaper_rect.height(),
161          true);
162    }
163  }
164}
165
166bool DesktopBackgroundView::OnMousePressed(const ui::MouseEvent& event) {
167  return true;
168}
169
170void DesktopBackgroundView::ShowContextMenuForView(
171    views::View* source,
172    const gfx::Point& point,
173    ui::MenuSourceType source_type) {
174  Shell::GetInstance()->ShowContextMenu(point, source_type);
175}
176
177views::Widget* CreateDesktopBackground(aura::RootWindow* root_window,
178                                       int container_id) {
179  DesktopBackgroundController* controller =
180      Shell::GetInstance()->desktop_background_controller();
181  UserWallpaperDelegate* wallpaper_delegate =
182      Shell::GetInstance()->user_wallpaper_delegate();
183
184  views::Widget* desktop_widget = new views::Widget;
185  views::Widget::InitParams params(
186      views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
187  if (controller->GetWallpaper().isNull())
188    params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
189  params.parent = root_window->GetChildById(container_id);
190  desktop_widget->Init(params);
191  desktop_widget->SetContentsView(
192      new LayerControlView(new DesktopBackgroundView()));
193  int animation_type = wallpaper_delegate->GetAnimationType();
194  views::corewm::SetWindowVisibilityAnimationType(
195      desktop_widget->GetNativeView(), animation_type);
196
197  RootWindowController* root_window_controller =
198      GetRootWindowController(root_window);
199
200  // Enable wallpaper transition for the following cases:
201  // 1. Initial(OOBE) wallpaper animation.
202  // 2. Wallpaper fades in from a non empty background.
203  // 3. From an empty background, chrome transit to a logged in user session.
204  // 4. From an empty background, guest user logged in.
205  if (wallpaper_delegate->ShouldShowInitialAnimation() ||
206      root_window_controller->animating_wallpaper_controller() ||
207      Shell::GetInstance()->session_state_delegate()->NumberOfLoggedInUsers()) {
208    views::corewm::SetWindowVisibilityAnimationTransition(
209        desktop_widget->GetNativeView(), views::corewm::ANIMATE_SHOW);
210  } else {
211    // Disable animation if transition to login screen from an empty background.
212    views::corewm::SetWindowVisibilityAnimationTransition(
213        desktop_widget->GetNativeView(), views::corewm::ANIMATE_NONE);
214  }
215
216  desktop_widget->SetBounds(params.parent->bounds());
217  return desktop_widget;
218}
219
220}  // namespace internal
221}  // namespace ash
222