| // Copyright 2015 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/display/extended_mouse_warp_controller.h" |
| |
| #include <cmath> |
| |
| #include "ash/display/display_manager.h" |
| #include "ash/display/display_util.h" |
| #include "ash/display/shared_display_edge_indicator.h" |
| #include "ash/root_window_controller.h" |
| #include "ash/screen_util.h" |
| #include "ash/shell.h" |
| #include "ui/aura/window.h" |
| #include "ui/events/event_utils.h" |
| #include "ui/gfx/screen.h" |
| #include "ui/wm/core/coordinate_conversion.h" |
| |
| namespace ash { |
| |
| namespace { |
| |
| // Maximum size on the display edge that initiate snapping phantom window, |
| // from the corner of the display. |
| const int kMaximumSnapHeight = 16; |
| |
| // Minimum height of an indicator on the display edge that allows |
| // dragging a window. If two displays shares the edge smaller than |
| // this, entire edge will be used as a draggable space. |
| const int kMinimumIndicatorHeight = 200; |
| |
| const int kIndicatorThickness = 1; |
| |
| } // namespace |
| |
| ExtendedMouseWarpController::ExtendedMouseWarpController( |
| aura::Window* drag_source) |
| : drag_source_root_(drag_source), |
| shared_display_edge_indicator_(new SharedDisplayEdgeIndicator), |
| allow_non_native_event_(false) { |
| DisplayLayout::Position position = Shell::GetInstance() |
| ->display_manager() |
| ->GetCurrentDisplayLayout() |
| .position; |
| // TODO(oshima): Use ComputeBondary instead. |
| if (position == DisplayLayout::TOP || position == DisplayLayout::BOTTOM) |
| UpdateHorizontalEdgeBounds(); |
| else |
| UpdateVerticalEdgeBounds(); |
| if (drag_source) { |
| shared_display_edge_indicator_->Show(src_indicator_bounds_, |
| dst_indicator_bounds_); |
| } |
| } |
| |
| ExtendedMouseWarpController::~ExtendedMouseWarpController() { |
| } |
| |
| bool ExtendedMouseWarpController::WarpMouseCursor(ui::MouseEvent* event) { |
| if (Shell::GetScreen()->GetNumDisplays() <= 1 || !enabled_) |
| return false; |
| |
| aura::Window* target = static_cast<aura::Window*>(event->target()); |
| gfx::Point point_in_screen = event->location(); |
| ::wm::ConvertPointToScreen(target, &point_in_screen); |
| |
| // A native event may not exist in unit test. Generate the native point |
| // from the screen point instead. |
| if (!event->HasNativeEvent()) { |
| if (!allow_non_native_event_) |
| return false; |
| aura::Window* target_root = target->GetRootWindow(); |
| gfx::Point point_in_native = point_in_screen; |
| ::wm::ConvertPointFromScreen(target_root, &point_in_native); |
| target_root->GetHost()->ConvertPointToNativeScreen(&point_in_native); |
| return WarpMouseCursorInNativeCoords(point_in_native, point_in_screen, |
| true); |
| } |
| |
| gfx::Point point_in_native = |
| ui::EventSystemLocationFromNative(event->native_event()); |
| |
| #if defined(USE_OZONE) |
| // TODO(dnicoara): crbug.com/415680 Move cursor warping into Ozone once Ozone |
| // has access to the logical display layout. |
| // Native events in Ozone are in the native window coordinate system. We need |
| // to translate them to get the global position. |
| point_in_native.Offset(target->GetHost()->GetBounds().x(), |
| target->GetHost()->GetBounds().y()); |
| #endif |
| |
| return WarpMouseCursorInNativeCoords(point_in_native, point_in_screen, false); |
| } |
| |
| void ExtendedMouseWarpController::SetEnabled(bool enabled) { |
| enabled_ = enabled; |
| } |
| |
| bool ExtendedMouseWarpController::WarpMouseCursorInNativeCoords( |
| const gfx::Point& point_in_native, |
| const gfx::Point& point_in_screen, |
| bool update_mouse_location_now) { |
| bool in_src_edge = src_edge_bounds_in_native_.Contains(point_in_native); |
| bool in_dst_edge = dst_edge_bounds_in_native_.Contains(point_in_native); |
| if (!in_src_edge && !in_dst_edge) |
| return false; |
| |
| // The mouse must move. |
| aura::Window* src_root = nullptr; |
| aura::Window* dst_root = nullptr; |
| GetSrcAndDstRootWindows(&src_root, &dst_root); |
| AshWindowTreeHost* target_ash_host = |
| GetRootWindowController(in_src_edge ? dst_root : src_root)->ash_host(); |
| |
| MoveCursorTo(target_ash_host, point_in_screen, update_mouse_location_now); |
| return true; |
| } |
| |
| void ExtendedMouseWarpController::UpdateHorizontalEdgeBounds() { |
| bool from_primary = Shell::GetPrimaryRootWindow() == drag_source_root_; |
| // GetPrimaryDisplay returns an object on stack, so copy the bounds |
| // instead of using reference. |
| const gfx::Rect primary_bounds = |
| Shell::GetScreen()->GetPrimaryDisplay().bounds(); |
| const gfx::Rect secondary_bounds = ScreenUtil::GetSecondaryDisplay().bounds(); |
| DisplayLayout::Position position = Shell::GetInstance() |
| ->display_manager() |
| ->GetCurrentDisplayLayout() |
| .position; |
| |
| src_indicator_bounds_.set_x( |
| std::max(primary_bounds.x(), secondary_bounds.x())); |
| src_indicator_bounds_.set_width( |
| std::min(primary_bounds.right(), secondary_bounds.right()) - |
| src_indicator_bounds_.x()); |
| src_indicator_bounds_.set_height(kIndicatorThickness); |
| src_indicator_bounds_.set_y( |
| position == DisplayLayout::TOP |
| ? primary_bounds.y() - (from_primary ? 0 : kIndicatorThickness) |
| : primary_bounds.bottom() - (from_primary ? kIndicatorThickness : 0)); |
| |
| dst_indicator_bounds_ = src_indicator_bounds_; |
| dst_indicator_bounds_.set_height(kIndicatorThickness); |
| dst_indicator_bounds_.set_y( |
| position == DisplayLayout::TOP |
| ? primary_bounds.y() - (from_primary ? kIndicatorThickness : 0) |
| : primary_bounds.bottom() - (from_primary ? 0 : kIndicatorThickness)); |
| |
| aura::Window* src_root = nullptr; |
| aura::Window* dst_root = nullptr; |
| GetSrcAndDstRootWindows(&src_root, &dst_root); |
| |
| src_edge_bounds_in_native_ = GetNativeEdgeBounds( |
| GetRootWindowController(src_root)->ash_host(), src_indicator_bounds_); |
| dst_edge_bounds_in_native_ = GetNativeEdgeBounds( |
| GetRootWindowController(dst_root)->ash_host(), dst_indicator_bounds_); |
| } |
| |
| void ExtendedMouseWarpController::UpdateVerticalEdgeBounds() { |
| int snap_height = drag_source_root_ ? kMaximumSnapHeight : 0; |
| bool in_primary = Shell::GetPrimaryRootWindow() == drag_source_root_; |
| // GetPrimaryDisplay returns an object on stack, so copy the bounds |
| // instead of using reference. |
| const gfx::Rect primary_bounds = |
| Shell::GetScreen()->GetPrimaryDisplay().bounds(); |
| const gfx::Rect secondary_bounds = ScreenUtil::GetSecondaryDisplay().bounds(); |
| DisplayLayout::Position position = Shell::GetInstance() |
| ->display_manager() |
| ->GetCurrentDisplayLayout() |
| .position; |
| |
| int upper_shared_y = std::max(primary_bounds.y(), secondary_bounds.y()); |
| int lower_shared_y = |
| std::min(primary_bounds.bottom(), secondary_bounds.bottom()); |
| int shared_height = lower_shared_y - upper_shared_y; |
| |
| int dst_x = |
| position == DisplayLayout::LEFT |
| ? primary_bounds.x() - (in_primary ? kIndicatorThickness : 0) |
| : primary_bounds.right() - (in_primary ? 0 : kIndicatorThickness); |
| dst_indicator_bounds_.SetRect(dst_x, upper_shared_y, kIndicatorThickness, |
| shared_height); |
| |
| // The indicator on the source display. |
| src_indicator_bounds_.set_width(kIndicatorThickness); |
| src_indicator_bounds_.set_x( |
| position == DisplayLayout::LEFT |
| ? primary_bounds.x() - (in_primary ? 0 : kIndicatorThickness) |
| : primary_bounds.right() - (in_primary ? kIndicatorThickness : 0)); |
| |
| const gfx::Rect& source_bounds = |
| in_primary ? primary_bounds : secondary_bounds; |
| int upper_indicator_y = source_bounds.y() + snap_height; |
| int lower_indicator_y = std::min(source_bounds.bottom(), lower_shared_y); |
| |
| // This gives a hight that can be used without sacrifying the snap space. |
| int available_space = |
| lower_indicator_y - std::max(upper_shared_y, upper_indicator_y); |
| |
| if (shared_height < kMinimumIndicatorHeight) { |
| // If the shared height is smaller than minimum height, use the |
| // entire height. |
| upper_indicator_y = upper_shared_y; |
| } else if (available_space < kMinimumIndicatorHeight) { |
| // Snap to the bottom. |
| upper_indicator_y = |
| std::max(upper_shared_y, lower_indicator_y + kMinimumIndicatorHeight); |
| } else { |
| upper_indicator_y = std::max(upper_indicator_y, upper_shared_y); |
| } |
| src_indicator_bounds_.set_y(upper_indicator_y); |
| src_indicator_bounds_.set_height(lower_indicator_y - upper_indicator_y); |
| |
| aura::Window* src_root = nullptr; |
| aura::Window* dst_root = nullptr; |
| GetSrcAndDstRootWindows(&src_root, &dst_root); |
| |
| // Native |
| src_edge_bounds_in_native_ = GetNativeEdgeBounds( |
| GetRootWindowController(src_root)->ash_host(), src_indicator_bounds_); |
| dst_edge_bounds_in_native_ = GetNativeEdgeBounds( |
| GetRootWindowController(dst_root)->ash_host(), dst_indicator_bounds_); |
| } |
| |
| void ExtendedMouseWarpController::GetSrcAndDstRootWindows( |
| aura::Window** src_root, |
| aura::Window** dst_root) { |
| aura::Window::Windows root_windows = Shell::GetAllRootWindows(); |
| *src_root = drag_source_root_ ? drag_source_root_ |
| : Shell::GetInstance()->GetPrimaryRootWindow(); |
| *dst_root = root_windows[0] == *src_root ? root_windows[1] : root_windows[0]; |
| } |
| |
| } // namespace ash |
