ash/wallpaper/wallpaper_view.cc - chromium/src - Git at Google

 // Copyright (c) 2012 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 "ash/wallpaper/wallpaper_view.h"

 #include "ash/public/cpp/window_animation_types.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_controller_impl.h"
 #include "ash/shell.h"
 #include "ash/wallpaper/wallpaper_controller.h"
 #include "ash/wallpaper/wallpaper_widget_controller.h"
 #include "ash/wm/overview/overview_controller.h"
 #include "ash/wm/overview/overview_utils.h"
 #include "cc/paint/render_surface_filters.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_animations.h"

 namespace ash {

 namespace {

 // A view that controls the child view's layer so that the layer always has the
 // same size as the display's original, un-scaled size in DIP. The layer is then
 // transformed to fit to the virtual screen size when laid-out. This is to avoid
 // scaling the image at painting time, then scaling it back to the screen size
 // in the compositor.
 class LayerControlView : public views::View {
  public:
   explicit LayerControlView(views::View* view) {
     AddChildView(view);
     view->SetPaintToLayer();
   }

   // Overrides views::View.
   void Layout() override {
     aura::Window* window = GetWidget()->GetNativeWindow();
     // Keep |this| at the bottom since there may be other windows on top of the
     // wallpaper view such as an overview mode shield.
     window->parent()->StackChildAtBottom(window);
     display::Display display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(window);

     display::ManagedDisplayInfo info =
         Shell::Get()->display_manager()->GetDisplayInfo(display.id());

     DCHECK_EQ(1u, children().size());
     views::View* child = children().front();
     child->SetBounds(0, 0, display.size().width(), display.size().height());
     gfx::Transform transform;
     // Apply RTL transform explicitly becacuse Views layer code
     // doesn't handle RTL.  crbug.com/458753.
     transform.Translate(-child->GetMirroredX(), 0);
     child->SetTransform(transform);
   }

  private:
   DISALLOW_COPY_AND_ASSIGN(LayerControlView);
 };

 }  // namespace

 // This event handler receives events in the pre-target phase and takes care of
 // the following:
 //   - Disabling overview mode on touch release.
 //   - Disabling overview mode on mouse release.
 class PreEventDispatchHandler : public ui::EventHandler {
  public:
   PreEventDispatchHandler() = default;
   ~PreEventDispatchHandler() override = default;

  private:
   // ui::EventHandler:
   void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_RELEASED)
       HandleClickOrTap(event);
   }

   void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_TAP)
       HandleClickOrTap(event);
   }

   void HandleClickOrTap(ui::Event* event) {
     CHECK_EQ(ui::EP_PRETARGET, event->phase());
     OverviewController* controller = Shell::Get()->overview_controller();
     if (!controller->InOverviewSession())
       return;
     // Events that happen while app list is sliding out during overview should
     // be ignored to prevent overview from disappearing out from under the user.
     if (!IsSlidingOutOverviewFromShelf())
       controller->ToggleOverview();
     event->StopPropagation();
   }

   DISALLOW_COPY_AND_ASSIGN(PreEventDispatchHandler);
 };

 ////////////////////////////////////////////////////////////////////////////////
 // WallpaperView, public:

 WallpaperView::WallpaperView(int blur, float opacity)
     : repaint_blur_(blur),
       repaint_opacity_(opacity),
       pre_dispatch_handler_(std::make_unique<PreEventDispatchHandler>()) {
   set_context_menu_controller(this);
   AddPreTargetHandler(pre_dispatch_handler_.get());
 }

 WallpaperView::~WallpaperView() {
   RemovePreTargetHandler(pre_dispatch_handler_.get());
 }

 void WallpaperView::RepaintBlurAndOpacity(int repaint_blur,
                                           float repaint_opacity) {
   if (repaint_blur_ == repaint_blur && repaint_opacity_ == repaint_opacity)
     return;

   repaint_blur_ = repaint_blur;
   repaint_opacity_ = repaint_opacity;
   SchedulePaint();
 }

 const char* WallpaperView::GetClassName() const {
   return "WallpaperView";
 }

 bool WallpaperView::OnMousePressed(const ui::MouseEvent& event) {
   return true;
 }

 void WallpaperView::ShowContextMenuForViewImpl(views::View* source,
                                                const gfx::Point& point,
                                                ui::MenuSourceType source_type) {
   Shell::Get()->ShowContextMenu(point, source_type);
 }

 void WallpaperView::DrawWallpaper(const gfx::ImageSkia& wallpaper,
                                   const gfx::Rect& src,
                                   const gfx::Rect& dst,
                                   const cc::PaintFlags& flags,
                                   gfx::Canvas* canvas) {
   // The amount we downsample the original image by before applying filters to
   // improve performance.
   constexpr float quality = 0.3f;
   gfx::Rect quality_adjusted_rect = gfx::ScaleToEnclosingRect(dst, quality);
   // Draw the wallpaper to a cached image the first time it is drawn or if the
   // size has changed.
   if (!small_image_ || small_image_->size() != quality_adjusted_rect.size()) {
     gfx::Canvas small_canvas(quality_adjusted_rect.size(),
                              /*image_scale=*/1.f,
                              /*is_opaque=*/false);
     small_canvas.DrawImageInt(wallpaper, src.x(), src.y(), src.width(),
                               src.height(), 0, 0, quality_adjusted_rect.width(),
                               quality_adjusted_rect.height(), true);
     small_image_ = base::make_optional(
         gfx::ImageSkia::CreateFrom1xBitmap(small_canvas.GetBitmap()));
   }

   if (repaint_blur_ == 0 && repaint_opacity_ == 1.f) {
     canvas->DrawImageInt(wallpaper, src.x(), src.y(), src.width(), src.height(),
                          dst.x(), dst.y(), dst.width(), dst.height(),
                          /*filter=*/true, flags);
     return;
   }

   float blur = repaint_blur_ * quality;
   // Create the blur and brightness filter to apply to the downsampled image.
   cc::PaintFlags filter_flags;
   cc::FilterOperations operations;
   operations.Append(
       cc::FilterOperation::CreateBrightnessFilter(repaint_opacity_));
   operations.Append(cc::FilterOperation::CreateBlurFilter(
       blur, SkBlurImageFilter::kClamp_TileMode));
   sk_sp<cc::PaintFilter> filter = cc::RenderSurfaceFilters::BuildImageFilter(
       operations, gfx::SizeF(dst.size()), gfx::Vector2dF());
   filter_flags.setImageFilter(filter);

   gfx::Canvas filtered_canvas(small_image_->size(),
                               /*image_scale=*/1.f,
                               /*is_opaque=*/false);
   filtered_canvas.sk_canvas()->saveLayer(nullptr, &filter_flags);
   filtered_canvas.DrawImageInt(
       *small_image_, 0, 0, small_image_->width(), small_image_->height(), 0, 0,
       small_image_->width(), small_image_->height(), true);
   filtered_canvas.sk_canvas()->restore();

   // Draw the downsampled and filtered image onto |canvas|. Draw a inseted
   // version of the image to avoid drawing a blackish border caused by the blur
   // filter. This is what we do on the login screen as well.
   gfx::ImageSkia filtered_wallpaper =
       gfx::ImageSkia::CreateFrom1xBitmap(filtered_canvas.GetBitmap());
   canvas->DrawImageInt(filtered_wallpaper, blur, blur,
                        small_image_->width() - 2 * blur,
                        small_image_->height() - 2 * blur, dst.x(), dst.y(),
                        dst.width(), dst.height(),
                        /*filter=*/true, flags);
 }

 views::Widget* CreateWallpaperWidget(aura::Window* root_window,
                                      int container_id,
                                      int blur,
                                      float opacity,
                                      WallpaperView** out_wallpaper_view) {
   WallpaperController* controller = Shell::Get()->wallpaper_controller();

   views::Widget* wallpaper_widget = new views::Widget;
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.name = "WallpaperView";
   if (controller->GetWallpaper().isNull())
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = root_window->GetChildById(container_id);
   wallpaper_widget->Init(params);
   // Owned by views.
   WallpaperView* wallpaper_view = new WallpaperView(blur, opacity);
   wallpaper_widget->SetContentsView(new LayerControlView(wallpaper_view));
   *out_wallpaper_view = wallpaper_view;
   int animation_type =
       controller->ShouldShowInitialAnimation()
           ? wm::WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE
           : ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE;
   aura::Window* wallpaper_window = wallpaper_widget->GetNativeWindow();
   ::wm::SetWindowVisibilityAnimationType(wallpaper_window, animation_type);

   // Enable wallpaper transition for the following cases:
   // 1. Initial(OOBE) wallpaper animation.
   // 2. Wallpaper fades in from a non empty background.
   // 3. From an empty background, chrome transit to a logged in user session.
   // 4. From an empty background, guest user logged in.
   if (controller->ShouldShowInitialAnimation() ||
       RootWindowController::ForWindow(root_window)
           ->wallpaper_widget_controller()
           ->IsAnimating() ||
       Shell::Get()->session_controller()->NumberOfLoggedInUsers()) {
     ::wm::SetWindowVisibilityAnimationTransition(wallpaper_window,
                                                  ::wm::ANIMATE_SHOW);
     base::TimeDelta animation_duration = controller->animation_duration();
     if (!animation_duration.is_zero()) {
       ::wm::SetWindowVisibilityAnimationDuration(wallpaper_window,
                                                  animation_duration);
     }
   } else {
     // Disable animation if transition to login screen from an empty background.
     ::wm::SetWindowVisibilityAnimationTransition(wallpaper_window,
                                                  ::wm::ANIMATE_NONE);
   }

   aura::Window* container = root_window->GetChildById(container_id);
   wallpaper_widget->SetBounds(container->bounds());

   return wallpaper_widget;
 }

 }  // namespace ash
	// Copyright (c) 2012 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 "ash/wallpaper/wallpaper_view.h"

	#include "ash/public/cpp/window_animation_types.h"
	#include "ash/root_window_controller.h"
	#include "ash/session/session_controller_impl.h"
	#include "ash/shell.h"
	#include "ash/wallpaper/wallpaper_controller.h"
	#include "ash/wallpaper/wallpaper_widget_controller.h"
	#include "ash/wm/overview/overview_controller.h"
	#include "ash/wm/overview/overview_utils.h"
	#include "cc/paint/render_surface_filters.h"
	#include "ui/aura/window.h"
	#include "ui/display/display.h"
	#include "ui/display/manager/display_manager.h"
	#include "ui/display/manager/managed_display_info.h"
	#include "ui/display/screen.h"
	#include "ui/gfx/canvas.h"
	#include "ui/gfx/geometry/size_conversions.h"
	#include "ui/gfx/transform.h"
	#include "ui/views/widget/widget.h"
	#include "ui/wm/core/window_animations.h"

	namespace ash {

	namespace {

	// A view that controls the child view's layer so that the layer always has the
	// same size as the display's original, un-scaled size in DIP. The layer is then
	// transformed to fit to the virtual screen size when laid-out. This is to avoid
	// scaling the image at painting time, then scaling it back to the screen size
	// in the compositor.
	class LayerControlView : public views::View {
	public:
	explicit LayerControlView(views::View* view) {
	AddChildView(view);
	view->SetPaintToLayer();
	}

	// Overrides views::View.
	void Layout() override {
	aura::Window* window = GetWidget()->GetNativeWindow();
	// Keep \|this\| at the bottom since there may be other windows on top of the
	// wallpaper view such as an overview mode shield.
	window->parent()->StackChildAtBottom(window);
	display::Display display =
	display::Screen::GetScreen()->GetDisplayNearestWindow(window);

	display::ManagedDisplayInfo info =
	Shell::Get()->display_manager()->GetDisplayInfo(display.id());

	DCHECK_EQ(1u, children().size());
	views::View* child = children().front();
	child->SetBounds(0, 0, display.size().width(), display.size().height());
	gfx::Transform transform;
	// Apply RTL transform explicitly becacuse Views layer code
	// doesn't handle RTL. crbug.com/458753.
	transform.Translate(-child->GetMirroredX(), 0);
	child->SetTransform(transform);
	}

	private:
	DISALLOW_COPY_AND_ASSIGN(LayerControlView);
	};

	} // namespace

	// This event handler receives events in the pre-target phase and takes care of
	// the following:
	// - Disabling overview mode on touch release.
	// - Disabling overview mode on mouse release.
	class PreEventDispatchHandler : public ui::EventHandler {
	public:
	PreEventDispatchHandler() = default;
	~PreEventDispatchHandler() override = default;

	private:
	// ui::EventHandler:
	void OnMouseEvent(ui::MouseEvent* event) override {
	if (event->type() == ui::ET_MOUSE_RELEASED)
	HandleClickOrTap(event);
	}

	void OnGestureEvent(ui::GestureEvent* event) override {
	if (event->type() == ui::ET_GESTURE_TAP)
	HandleClickOrTap(event);
	}

	void HandleClickOrTap(ui::Event* event) {
	CHECK_EQ(ui::EP_PRETARGET, event->phase());
	OverviewController* controller = Shell::Get()->overview_controller();
	if (!controller->InOverviewSession())
	return;
	// Events that happen while app list is sliding out during overview should
	// be ignored to prevent overview from disappearing out from under the user.
	if (!IsSlidingOutOverviewFromShelf())
	controller->ToggleOverview();
	event->StopPropagation();
	}

	DISALLOW_COPY_AND_ASSIGN(PreEventDispatchHandler);
	};

	////////////////////////////////////////////////////////////////////////////////
	// WallpaperView, public:

	WallpaperView::WallpaperView(int blur, float opacity)
	: repaint_blur_(blur),
	repaint_opacity_(opacity),
	pre_dispatch_handler_(std::make_unique<PreEventDispatchHandler>()) {
	set_context_menu_controller(this);
	AddPreTargetHandler(pre_dispatch_handler_.get());
	}

	WallpaperView::~WallpaperView() {
	RemovePreTargetHandler(pre_dispatch_handler_.get());
	}

	void WallpaperView::RepaintBlurAndOpacity(int repaint_blur,
	float repaint_opacity) {
	if (repaint_blur_ == repaint_blur && repaint_opacity_ == repaint_opacity)
	return;

	repaint_blur_ = repaint_blur;
	repaint_opacity_ = repaint_opacity;
	SchedulePaint();
	}

	const char* WallpaperView::GetClassName() const {
	return "WallpaperView";
	}

	bool WallpaperView::OnMousePressed(const ui::MouseEvent& event) {
	return true;
	}

	void WallpaperView::ShowContextMenuForViewImpl(views::View* source,
	const gfx::Point& point,
	ui::MenuSourceType source_type) {
	Shell::Get()->ShowContextMenu(point, source_type);
	}

	void WallpaperView::DrawWallpaper(const gfx::ImageSkia& wallpaper,
	const gfx::Rect& src,
	const gfx::Rect& dst,
	const cc::PaintFlags& flags,
	gfx::Canvas* canvas) {
	// The amount we downsample the original image by before applying filters to
	// improve performance.
	constexpr float quality = 0.3f;
	gfx::Rect quality_adjusted_rect = gfx::ScaleToEnclosingRect(dst, quality);
	// Draw the wallpaper to a cached image the first time it is drawn or if the
	// size has changed.
	if (!small_image_ \|\| small_image_->size() != quality_adjusted_rect.size()) {
	gfx::Canvas small_canvas(quality_adjusted_rect.size(),
	/image_scale=/1.f,
	/is_opaque=/false);
	small_canvas.DrawImageInt(wallpaper, src.x(), src.y(), src.width(),
	src.height(), 0, 0, quality_adjusted_rect.width(),
	quality_adjusted_rect.height(), true);
	small_image_ = base::make_optional(
	gfx::ImageSkia::CreateFrom1xBitmap(small_canvas.GetBitmap()));
	}

	if (repaint_blur_ == 0 && repaint_opacity_ == 1.f) {
	canvas->DrawImageInt(wallpaper, src.x(), src.y(), src.width(), src.height(),
	dst.x(), dst.y(), dst.width(), dst.height(),
	/filter=/true, flags);
	return;
	}

	float blur = repaint_blur_ * quality;
	// Create the blur and brightness filter to apply to the downsampled image.
	cc::PaintFlags filter_flags;
	cc::FilterOperations operations;
	operations.Append(
	cc::FilterOperation::CreateBrightnessFilter(repaint_opacity_));
	operations.Append(cc::FilterOperation::CreateBlurFilter(
	blur, SkBlurImageFilter::kClamp_TileMode));
	sk_sp<cc::PaintFilter> filter = cc::RenderSurfaceFilters::BuildImageFilter(
	operations, gfx::SizeF(dst.size()), gfx::Vector2dF());
	filter_flags.setImageFilter(filter);

	gfx::Canvas filtered_canvas(small_image_->size(),
	/image_scale=/1.f,
	/is_opaque=/false);
	filtered_canvas.sk_canvas()->saveLayer(nullptr, &filter_flags);
	filtered_canvas.DrawImageInt(
	*small_image_, 0, 0, small_image_->width(), small_image_->height(), 0, 0,
	small_image_->width(), small_image_->height(), true);
	filtered_canvas.sk_canvas()->restore();

	// Draw the downsampled and filtered image onto \|canvas\|. Draw a inseted
	// version of the image to avoid drawing a blackish border caused by the blur
	// filter. This is what we do on the login screen as well.
	gfx::ImageSkia filtered_wallpaper =
	gfx::ImageSkia::CreateFrom1xBitmap(filtered_canvas.GetBitmap());
	canvas->DrawImageInt(filtered_wallpaper, blur, blur,
	small_image_->width() - 2 * blur,
	small_image_->height() - 2 * blur, dst.x(), dst.y(),
	dst.width(), dst.height(),
	/filter=/true, flags);
	}

	views::Widget* CreateWallpaperWidget(aura::Window* root_window,
	int container_id,
	int blur,
	float opacity,
	WallpaperView** out_wallpaper_view) {
	WallpaperController* controller = Shell::Get()->wallpaper_controller();

	views::Widget* wallpaper_widget = new views::Widget;
	views::Widget::InitParams params(
	views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
	params.name = "WallpaperView";
	if (controller->GetWallpaper().isNull())
	params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
	params.parent = root_window->GetChildById(container_id);
	wallpaper_widget->Init(params);
	// Owned by views.
	WallpaperView* wallpaper_view = new WallpaperView(blur, opacity);
	wallpaper_widget->SetContentsView(new LayerControlView(wallpaper_view));
	*out_wallpaper_view = wallpaper_view;
	int animation_type =
	controller->ShouldShowInitialAnimation()
	? wm::WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE
	: ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE;
	aura::Window* wallpaper_window = wallpaper_widget->GetNativeWindow();
	::wm::SetWindowVisibilityAnimationType(wallpaper_window, animation_type);

	// Enable wallpaper transition for the following cases:
	// 1. Initial(OOBE) wallpaper animation.
	// 2. Wallpaper fades in from a non empty background.
	// 3. From an empty background, chrome transit to a logged in user session.
	// 4. From an empty background, guest user logged in.
	if (controller->ShouldShowInitialAnimation() \|\|
	RootWindowController::ForWindow(root_window)
	->wallpaper_widget_controller()
	->IsAnimating() \|\|
	Shell::Get()->session_controller()->NumberOfLoggedInUsers()) {
	::wm::SetWindowVisibilityAnimationTransition(wallpaper_window,
	::wm::ANIMATE_SHOW);
	base::TimeDelta animation_duration = controller->animation_duration();
	if (!animation_duration.is_zero()) {
	::wm::SetWindowVisibilityAnimationDuration(wallpaper_window,
	animation_duration);
	}
	} else {
	// Disable animation if transition to login screen from an empty background.
	::wm::SetWindowVisibilityAnimationTransition(wallpaper_window,
	::wm::ANIMATE_NONE);
	}

	aura::Window* container = root_window->GetChildById(container_id);
	wallpaper_widget->SetBounds(container->bounds());

	return wallpaper_widget;
	}

	} // namespace ash