ash/display/cursor_window_controller.cc

   1 // Copyright 2014 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/display/cursor_window_controller.h"
   6
   7 #include "ash/display/display_controller.h"
   8 #include "ash/display/mirror_window_controller.h"
   9 #include "ash/root_window_controller.h"
  10 #include "ash/shell.h"
  11 #include "ash/shell_window_ids.h"
  12 #include "ui/aura/env.h"
  13 #include "ui/aura/window_delegate.h"
  14 #include "ui/aura/window_event_dispatcher.h"
  15 #include "ui/base/cursor/cursors_aura.h"
  16 #include "ui/base/hit_test.h"
  17 #include "ui/base/resource/resource_bundle.h"
  18 #include "ui/compositor/dip_util.h"
  19 #include "ui/gfx/canvas.h"
  20 #include "ui/gfx/display.h"
  21 #include "ui/gfx/image/image_skia.h"
  22 #include "ui/gfx/image/image_skia_operations.h"
  23
  24 namespace ash {
  25
  26 class CursorWindowDelegate : public aura::WindowDelegate {
  27  public:
  28   CursorWindowDelegate() : is_cursor_compositing_enabled_(false) {}
  29   ~CursorWindowDelegate() override {}
  30
  31   // aura::WindowDelegate overrides:
  32   gfx::Size GetMinimumSize() const override { return size_; }
  33   gfx::Size GetMaximumSize() const override { return size_; }
  34   void OnBoundsChanged(const gfx::Rect& old_bounds,
  35                        const gfx::Rect& new_bounds) override {}
  36   ui::TextInputClient* GetFocusedTextInputClient() override { return nullptr; }
  37   gfx::NativeCursor GetCursor(const gfx::Point& point) override {
  38     return gfx::kNullCursor;
  39   }
  40   int GetNonClientComponent(const gfx::Point& point) const override {
  41     return HTNOWHERE;
  42   }
  43   bool ShouldDescendIntoChildForEventHandling(
  44       aura::Window* child,
  45       const gfx::Point& location) override {
  46     return false;
  47   }
  48   bool CanFocus() override { return false; }
  49   void OnCaptureLost() override {}
  50   void OnPaint(gfx::Canvas* canvas) override {
  51     canvas->DrawImageInt(cursor_image_, 0, 0);
  52   }
  53   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
  54   void OnWindowDestroying(aura::Window* window) override {}
  55   void OnWindowDestroyed(aura::Window* window) override {}
  56   void OnWindowTargetVisibilityChanged(bool visible) override {}
  57   bool HasHitTestMask() const override { return false; }
  58   void GetHitTestMask(gfx::Path* mask) const override {}
  59
  60   // Sets cursor compositing mode on/off.
  61   void SetCursorCompositingEnabled(bool enabled) {
  62     is_cursor_compositing_enabled_ = enabled;
  63   }
  64
  65   // Sets the cursor image for the |display|'s scale factor.
  66   void SetCursorImage(const gfx::ImageSkia& image,
  67                       const gfx::Display& display) {
  68     float scale_factor = display.device_scale_factor();
  69     const gfx::ImageSkiaRep& image_rep = image.GetRepresentation(scale_factor);
  70     if (!is_cursor_compositing_enabled_) {
  71       // Note that mirror window's scale factor is always 1.0f, therefore we
  72       // need to take 2x's image and paint as if it's 1x image.
  73       size_ = image_rep.pixel_size();
  74       cursor_image_ = gfx::ImageSkia::CreateFrom1xBitmap(image_rep.sk_bitmap());
  75     } else {
  76       size_ = image.size();
  77       cursor_image_ = gfx::ImageSkia(
  78           gfx::ImageSkiaRep(image_rep.sk_bitmap(), scale_factor));
  79     }
  80   }
  81
  82   const gfx::Size size() const { return size_; }
  83
  84  private:
  85   bool is_cursor_compositing_enabled_;
  86   gfx::ImageSkia cursor_image_;
  87   gfx::Size size_;
  88
  89   DISALLOW_COPY_AND_ASSIGN(CursorWindowDelegate);
  90 };
  91
  92 CursorWindowController::CursorWindowController()
  93     : is_cursor_compositing_enabled_(false),
  94       container_(NULL),
  95       cursor_type_(ui::kCursorNone),
  96       visible_(true),
  97       cursor_set_(ui::CURSOR_SET_NORMAL),
  98       delegate_(new CursorWindowDelegate()) {
  99 }
 100
 101 CursorWindowController::~CursorWindowController() {
 102   SetContainer(NULL);
 103 }
 104
 105 void CursorWindowController::SetCursorCompositingEnabled(bool enabled) {
 106   if (is_cursor_compositing_enabled_ != enabled) {
 107     is_cursor_compositing_enabled_ = enabled;
 108     delegate_->SetCursorCompositingEnabled(enabled);
 109     UpdateCursorImage();
 110     UpdateContainer();
 111   }
 112 }
 113
 114 void CursorWindowController::UpdateContainer() {
 115   if (is_cursor_compositing_enabled_) {
 116     gfx::Screen* screen = Shell::GetScreen();
 117     gfx::Display display = screen->GetDisplayNearestPoint(
 118         screen->GetCursorScreenPoint());
 119     DCHECK(display.is_valid());
 120     if (display.is_valid())
 121       SetDisplay(display);
 122   } else {
 123     aura::Window* mirror_window = Shell::GetInstance()->
 124         display_controller()->
 125         mirror_window_controller()->
 126         GetWindow();
 127     if (mirror_window)
 128       display_ = Shell::GetScreen()->GetPrimaryDisplay();
 129     SetContainer(mirror_window);
 130   }
 131   // Updates the hot point based on the current display.
 132   UpdateCursorImage();
 133 }
 134
 135 void CursorWindowController::SetDisplay(const gfx::Display& display) {
 136   if (!is_cursor_compositing_enabled_)
 137     return;
 138
 139   display_ = display;
 140   aura::Window* root_window = Shell::GetInstance()->display_controller()->
 141       GetRootWindowForDisplayId(display.id());
 142   if (!root_window)
 143     return;
 144
 145   SetContainer(GetRootWindowController(root_window)->GetContainer(
 146       kShellWindowId_MouseCursorContainer));
 147   SetBoundsInScreen(display.bounds());
 148   // Updates the hot point based on the current display.
 149   UpdateCursorImage();
 150 }
 151
 152 void CursorWindowController::UpdateLocation() {
 153   if (!cursor_window_)
 154     return;
 155   gfx::Point point = aura::Env::GetInstance()->last_mouse_location();
 156   if (!is_cursor_compositing_enabled_) {
 157     Shell::GetPrimaryRootWindow()->GetHost()->ConvertPointToHost(&point);
 158   } else {
 159     point.Offset(-bounds_in_screen_.x(), -bounds_in_screen_.y());
 160   }
 161   point.Offset(-hot_point_.x(), -hot_point_.y());
 162   gfx::Rect bounds = cursor_window_->bounds();
 163   bounds.set_origin(point);
 164   cursor_window_->SetBounds(bounds);
 165 }
 166
 167 void CursorWindowController::SetCursor(gfx::NativeCursor cursor) {
 168   if (cursor_type_ == cursor.native_type())
 169     return;
 170   cursor_type_ = cursor.native_type();
 171   UpdateCursorImage();
 172   UpdateCursorVisibility();
 173 }
 174
 175 void CursorWindowController::SetCursorSet(ui::CursorSetType cursor_set) {
 176   cursor_set_ = cursor_set;
 177   UpdateCursorImage();
 178 }
 179
 180 void CursorWindowController::SetVisibility(bool visible) {
 181   if (!cursor_window_)
 182     return;
 183   visible_ = visible;
 184   UpdateCursorVisibility();
 185 }
 186
 187 void CursorWindowController::SetContainer(aura::Window* container) {
 188   if (container_ == container)
 189     return;
 190   container_ = container;
 191   if (!container) {
 192     cursor_window_.reset();
 193     return;
 194   }
 195
 196   // Reusing the window does not work when the display is disconnected.
 197   // Just creates a new one instead. crbug.com/384218.
 198   cursor_window_.reset(new aura::Window(delegate_.get()));
 199   cursor_window_->SetTransparent(true);
 200   cursor_window_->Init(aura::WINDOW_LAYER_TEXTURED);
 201   cursor_window_->set_ignore_events(true);
 202   cursor_window_->set_owned_by_parent(false);
 203   // Call UpdateCursorImage() to figure out |cursor_window_|'s desired size.
 204   UpdateCursorImage();
 205
 206   container->AddChild(cursor_window_.get());
 207   UpdateCursorVisibility();
 208   SetBoundsInScreen(container->bounds());
 209 }
 210
 211 void CursorWindowController::SetBoundsInScreen(const gfx::Rect& bounds) {
 212   bounds_in_screen_ = bounds;
 213   UpdateLocation();
 214 }
 215
 216 void CursorWindowController::UpdateCursorImage() {
 217   int resource_id;
 218   // TODO(hshi): support custom cursor set.
 219   if (!ui::GetCursorDataFor(cursor_set_,
 220                             cursor_type_,
 221                             display_.device_scale_factor(),
 222                             &resource_id,
 223                             &hot_point_)) {
 224     return;
 225   }
 226   const gfx::ImageSkia* image =
 227       ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
 228   gfx::ImageSkia rotated = *image;
 229   if (!is_cursor_compositing_enabled_) {
 230     switch (display_.rotation()) {
 231       case gfx::Display::ROTATE_0:
 232         break;
 233       case gfx::Display::ROTATE_90:
 234         rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
 235             *image, SkBitmapOperations::ROTATION_90_CW);
 236         hot_point_.SetPoint(
 237             rotated.width() - hot_point_.y(),
 238             hot_point_.x());
 239         break;
 240       case gfx::Display::ROTATE_180:
 241         rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
 242             *image, SkBitmapOperations::ROTATION_180_CW);
 243         hot_point_.SetPoint(
 244             rotated.height() - hot_point_.x(),
 245             rotated.width() - hot_point_.y());
 246         break;
 247       case gfx::Display::ROTATE_270:
 248         rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
 249             *image, SkBitmapOperations::ROTATION_270_CW);
 250         hot_point_.SetPoint(
 251             hot_point_.y(),
 252             rotated.height() - hot_point_.x());
 253         break;
 254     }
 255   } else {
 256     hot_point_ = ui::ConvertPointToDIP(Shell::GetPrimaryRootWindow()->layer(),
 257                                        hot_point_);
 258   }
 259   delegate_->SetCursorImage(rotated, display_);
 260   if (cursor_window_) {
 261     cursor_window_->SetBounds(gfx::Rect(delegate_->size()));
 262     cursor_window_->SchedulePaintInRect(
 263         gfx::Rect(cursor_window_->bounds().size()));
 264     UpdateLocation();
 265   }
 266 }
 267
 268 void CursorWindowController::UpdateCursorVisibility() {
 269   if (!cursor_window_)
 270     return;
 271   bool visible = (visible_ && cursor_type_ != ui::kCursorNone);
 272   if (visible)
 273     cursor_window_->Show();
 274   else
 275     cursor_window_->Hide();
 276 }
 277
 278 }  // namespace ash