src/ash/wm/workspace/phantom_window_controller.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/wm/workspace/phantom_window_controller.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/shell_window_ids.h"
   9 #include "ash/wm/coordinate_conversion.h"
  10 #include "third_party/skia/include/core/SkCanvas.h"
  11 #include "ui/aura/root_window.h"
  12 #include "ui/aura/window.h"
  13 #include "ui/compositor/layer.h"
  14 #include "ui/compositor/scoped_layer_animation_settings.h"
  15 #include "ui/gfx/animation/slide_animation.h"
  16 #include "ui/gfx/canvas.h"
  17 #include "ui/gfx/skia_util.h"
  18 #include "ui/views/painter.h"
  19 #include "ui/views/view.h"
  20 #include "ui/views/widget/widget.h"
  21
  22
  23 namespace ash {
  24 namespace internal {
  25
  26 // EdgePainter ----------------------------------------------------------------
  27
  28 namespace {
  29
  30 // Paints the background of the phantom window for window snapping.
  31 class EdgePainter : public views::Painter {
  32  public:
  33   EdgePainter();
  34   virtual ~EdgePainter();
  35
  36   // views::Painter:
  37   virtual gfx::Size GetMinimumSize() const OVERRIDE;
  38   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
  39
  40  private:
  41   DISALLOW_COPY_AND_ASSIGN(EdgePainter);
  42 };
  43
  44 }  // namespace
  45
  46
  47 EdgePainter::EdgePainter() {
  48 }
  49
  50 EdgePainter::~EdgePainter() {
  51 }
  52
  53 gfx::Size EdgePainter::GetMinimumSize() const {
  54   return gfx::Size();
  55 }
  56
  57 void EdgePainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
  58   const int kInsetSize = 4;
  59   int x = kInsetSize;
  60   int y = kInsetSize;
  61   int w = size.width() - kInsetSize * 2;
  62   int h = size.height() - kInsetSize * 2;
  63   bool inset = (w > 0 && h > 0);
  64   if (!inset) {
  65     x = 0;
  66     y = 0;
  67     w = size.width();
  68     h = size.height();
  69   }
  70   SkPaint paint;
  71   paint.setColor(SkColorSetARGB(100, 0, 0, 0));
  72   paint.setStyle(SkPaint::kFill_Style);
  73   paint.setAntiAlias(true);
  74   const int kRoundRectSize = 4;
  75   canvas->sk_canvas()->drawRoundRect(
  76       gfx::RectToSkRect(gfx::Rect(x, y, w, h)),
  77       SkIntToScalar(kRoundRectSize), SkIntToScalar(kRoundRectSize), paint);
  78   if (!inset)
  79     return;
  80
  81   paint.setColor(SkColorSetARGB(200, 255, 255, 255));
  82   paint.setStyle(SkPaint::kStroke_Style);
  83   paint.setStrokeWidth(SkIntToScalar(2));
  84   canvas->sk_canvas()->drawRoundRect(
  85       gfx::RectToSkRect(gfx::Rect(x, y, w, h)), SkIntToScalar(kRoundRectSize),
  86       SkIntToScalar(kRoundRectSize), paint);
  87 }
  88
  89
  90 // PhantomWindowController ----------------------------------------------------
  91
  92 PhantomWindowController::PhantomWindowController(aura::Window* window)
  93     : window_(window),
  94       phantom_below_window_(NULL),
  95       phantom_widget_(NULL),
  96       phantom_widget_start_(NULL) {
  97 }
  98
  99 PhantomWindowController::~PhantomWindowController() {
 100   Hide();
 101 }
 102
 103 void PhantomWindowController::Show(const gfx::Rect& bounds_in_screen) {
 104   if (bounds_in_screen == bounds_in_screen_)
 105     return;
 106   bounds_in_screen_ = bounds_in_screen;
 107   aura::Window* target_root = wm::GetRootWindowMatching(bounds_in_screen);
 108   // Show the phantom at the current bounds of the window. We'll animate to the
 109   // target bounds. If phantom exists, update the start bounds.
 110   if (!phantom_widget_)
 111     start_bounds_ = window_->GetBoundsInScreen();
 112   else
 113     start_bounds_ = phantom_widget_->GetWindowBoundsInScreen();
 114   if (phantom_widget_ &&
 115       phantom_widget_->GetNativeWindow()->GetRootWindow() != target_root) {
 116     phantom_widget_->Close();
 117     phantom_widget_ = NULL;
 118   }
 119   if (!phantom_widget_)
 120     phantom_widget_ = CreatePhantomWidget(target_root, start_bounds_);
 121
 122   // Create a secondary widget in a second screen if start_bounds_ lie at least
 123   // partially in that other screen. This allows animations to start or restart
 124   // in one root window and progress into another root.
 125   aura::Window* start_root = wm::GetRootWindowMatching(start_bounds_);
 126   if (start_root == target_root) {
 127     Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 128     for (size_t i = 0; i < root_windows.size(); ++i) {
 129       if (root_windows[i] != target_root &&
 130           root_windows[i]->GetBoundsInScreen().Intersects(start_bounds_)) {
 131         start_root = root_windows[i];
 132         break;
 133       }
 134     }
 135   }
 136   if (phantom_widget_start_ &&
 137       (phantom_widget_start_->GetNativeWindow()->GetRootWindow() != start_root
 138        || start_root == target_root)) {
 139     phantom_widget_start_->Close();
 140     phantom_widget_start_ = NULL;
 141   }
 142   if (!phantom_widget_start_ && start_root != target_root)
 143     phantom_widget_start_ = CreatePhantomWidget(start_root, start_bounds_);
 144
 145   animation_.reset(new gfx::SlideAnimation(this));
 146   animation_->SetTweenType(gfx::Tween::EASE_IN);
 147   const int kAnimationDurationMS = 200;
 148   animation_->SetSlideDuration(kAnimationDurationMS);
 149   animation_->Show();
 150 }
 151
 152 void PhantomWindowController::Hide() {
 153   if (phantom_widget_)
 154     phantom_widget_->Close();
 155   phantom_widget_ = NULL;
 156   if (phantom_widget_start_)
 157     phantom_widget_start_->Close();
 158   phantom_widget_start_ = NULL;
 159 }
 160
 161 bool PhantomWindowController::IsShowing() const {
 162   return phantom_widget_ != NULL;
 163 }
 164
 165 void PhantomWindowController::AnimationProgressed(
 166     const gfx::Animation* animation) {
 167   const gfx::Rect current_bounds =
 168       animation->CurrentValueBetween(start_bounds_, bounds_in_screen_);
 169   if (phantom_widget_start_)
 170     phantom_widget_start_->SetBounds(current_bounds);
 171   phantom_widget_->SetBounds(current_bounds);
 172 }
 173
 174 views::Widget* PhantomWindowController::CreatePhantomWidget(
 175     aura::Window* root_window,
 176     const gfx::Rect& bounds_in_screen) {
 177   views::Widget* phantom_widget = new views::Widget;
 178   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
 179   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
 180   // PhantomWindowController is used by FrameMaximizeButton to highlight the
 181   // launcher button. Put the phantom in the same window as the launcher so that
 182   // the phantom is visible.
 183   params.parent = Shell::GetContainer(root_window,
 184                                       kShellWindowId_ShelfContainer);
 185   params.can_activate = false;
 186   params.keep_on_top = true;
 187   phantom_widget->set_focus_on_creation(false);
 188   phantom_widget->Init(params);
 189   phantom_widget->SetVisibilityChangedAnimationsEnabled(false);
 190   phantom_widget->GetNativeWindow()->SetName("PhantomWindow");
 191   phantom_widget->GetNativeWindow()->set_id(kShellWindowId_PhantomWindow);
 192   views::View* content_view = new views::View;
 193   content_view->set_background(
 194       views::Background::CreateBackgroundPainter(true, new EdgePainter));
 195   phantom_widget->SetContentsView(content_view);
 196   phantom_widget->SetBounds(bounds_in_screen);
 197   if (phantom_below_window_)
 198     phantom_widget->StackBelow(phantom_below_window_);
 199   else
 200     phantom_widget->StackAbove(window_);
 201
 202   // Show the widget after all the setups.
 203   phantom_widget->Show();
 204
 205   // Fade the window in.
 206   ui::Layer* widget_layer = phantom_widget->GetNativeWindow()->layer();
 207   widget_layer->SetOpacity(0);
 208   ui::ScopedLayerAnimationSettings scoped_setter(widget_layer->GetAnimator());
 209   widget_layer->SetOpacity(1);
 210   return phantom_widget;
 211 }
 212
 213 }  // namespace internal
 214 }  // namespace ash