src/ash/desktop_background/desktop_background_view.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 "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.
  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:
  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
  79 DesktopBackgroundView::DesktopBackgroundView() {
  80   set_context_menu_controller(this);
  81 }
  82
  83 DesktopBackgroundView::~DesktopBackgroundView() {
  84 }
  85
  86 ////////////////////////////////////////////////////////////////////////////////
  87 // DesktopBackgroundView, views::View overrides:
  88
  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.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
 166 bool DesktopBackgroundView::OnMousePressed(const ui::MouseEvent& event) {
 167   return true;
 168 }
 169
 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
 177 views::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