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
30 namespace ash {
31 namespace internal {
32 namespace {
33
34 // For our scaling ratios we need to round positive numbers.
RoundPositive(double x)35 int 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.
45 class LayerControlView : public views::View {
46 public:
LayerControlView(views::View * view)47 explicit LayerControlView(views::View* view) {
48 AddChildView(view);
49 view->SetPaintToLayer(true);
50 }
51
52 // Overrides views::View.
Layout()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 float ui_scale = info.GetEffectiveUIScale();
59 gfx::SizeF pixel_size = display.size();
60 pixel_size.Scale(1.0f / 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(ui_scale, 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
DesktopBackgroundView()79 DesktopBackgroundView::DesktopBackgroundView() {
80 set_context_menu_controller(this);
81 }
82
~DesktopBackgroundView()83 DesktopBackgroundView::~DesktopBackgroundView() {
84 }
85
86 ////////////////////////////////////////////////////////////////////////////////
87 // DesktopBackgroundView, views::View overrides:
88
OnPaint(gfx::Canvas * canvas)89 void 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.GetEffectiveUIScale();
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
OnMousePressed(const ui::MouseEvent & event)166 bool DesktopBackgroundView::OnMousePressed(const ui::MouseEvent& event) {
167 return true;
168 }
169
ShowContextMenuForView(views::View * source,const gfx::Point & point,ui::MenuSourceType source_type)170 void 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
CreateDesktopBackground(aura::Window * root_window,int container_id)177 views::Widget* CreateDesktopBackground(aura::Window* 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