1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// 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/unified_mouse_warp_controller.h"
#include <cmath>
#include "ash/display/display_manager.h"
#include "ash/display/display_util.h"
#include "ash/display/mirror_window_controller.h"
#include "ash/display/window_tree_host_manager.h"
#include "ash/host/ash_window_tree_host.h"
#include "ash/shell.h"
#include "ui/aura/client/cursor_client.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/layout.h"
#include "ui/events/event_utils.h"
#include "ui/gfx/screen.h"
#include "ui/wm/core/coordinate_conversion.h"
namespace ash {
namespace {
AshWindowTreeHost* GetMirroringAshWindowTreeHostForDisplayId(
int64_t display_id) {
return Shell::GetInstance()
->window_tree_host_manager()
->mirror_window_controller()
->GetAshWindowTreeHostForDisplayId(display_id);
}
#if defined(USE_OZONE)
// Find a WindowTreeHost used for mirroring displays that contains
// the |point_in_screen|. Returns nullptr if such WTH does not exist.
aura::WindowTreeHost* FindMirroringWindowTreeHostFromScreenPoint(
const gfx::Point& point_in_screen) {
DisplayList mirroring_display_list = Shell::GetInstance()
->display_manager()
->software_mirroring_display_list();
int index =
FindDisplayIndexContainingPoint(mirroring_display_list, point_in_screen);
if (index < 0)
return nullptr;
return GetMirroringAshWindowTreeHostForDisplayId(
mirroring_display_list[index].id())->AsWindowTreeHost();
}
#endif
} // namespace
UnifiedMouseWarpController::UnifiedMouseWarpController()
: current_cursor_display_id_(gfx::Display::kInvalidDisplayID),
update_location_for_test_(false) {}
UnifiedMouseWarpController::~UnifiedMouseWarpController() {
}
bool UnifiedMouseWarpController::WarpMouseCursor(ui::MouseEvent* event) {
// Mirroring windows are created asynchronously, so compute the edge
// beounds when we received an event instead of in constructor.
if (first_edge_bounds_in_native_.IsEmpty())
ComputeBounds();
aura::Window* target = static_cast<aura::Window*>(event->target());
gfx::Point point_in_unified_host = event->location();
::wm::ConvertPointToScreen(target, &point_in_unified_host);
// The display bounds of the mirroring windows isn't scaled, so
// transform back to the host coordinates.
target->GetHost()->GetRootTransform().TransformPoint(&point_in_unified_host);
if (current_cursor_display_id_ != gfx::Display::kInvalidDisplayID) {
aura::client::CursorClient* cursor_client =
aura::client::GetCursorClient(target->GetRootWindow());
if (cursor_client) {
DisplayList mirroring_display_list =
Shell::GetInstance()
->display_manager()
->software_mirroring_display_list();
int index = FindDisplayIndexContainingPoint(mirroring_display_list,
point_in_unified_host);
if (index >= 0) {
const gfx::Display& new_display = mirroring_display_list[index];
if (current_cursor_display_id_ != new_display.id()) {
cursor_client->SetDisplay(new_display);
current_cursor_display_id_ = gfx::Display::kInvalidDisplayID;
}
}
}
}
// A native event may not exist in unit test.
if (!event->HasNativeEvent())
return false;
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.
aura::WindowTreeHost* host =
FindMirroringWindowTreeHostFromScreenPoint(point_in_unified_host);
if (!host)
return false;
point_in_native.Offset(host->GetBounds().x(), host->GetBounds().y());
#endif
return WarpMouseCursorInNativeCoords(point_in_native, point_in_unified_host,
update_location_for_test_);
}
void UnifiedMouseWarpController::SetEnabled(bool enabled) {
// Mouse warp shuld be always on in Unified mode.
}
void UnifiedMouseWarpController::ComputeBounds() {
DisplayList display_list = Shell::GetInstance()
->display_manager()
->software_mirroring_display_list();
if (display_list.size() < 2) {
LOG(ERROR) << "Mirroring Display lost during re-configuration";
return;
}
LOG_IF(ERROR, display_list.size() > 2) << "Only two displays are supported";
const gfx::Display& first = display_list[0];
const gfx::Display& second = display_list[1];
bool success = ComputeBoundary(first, second, &first_edge_bounds_in_native_,
&second_edge_bounds_in_native_);
DCHECK(success);
first_edge_bounds_in_native_ =
GetNativeEdgeBounds(GetMirroringAshWindowTreeHostForDisplayId(first.id()),
first_edge_bounds_in_native_);
second_edge_bounds_in_native_ = GetNativeEdgeBounds(
GetMirroringAshWindowTreeHostForDisplayId(second.id()),
second_edge_bounds_in_native_);
}
bool UnifiedMouseWarpController::WarpMouseCursorInNativeCoords(
const gfx::Point& point_in_native,
const gfx::Point& point_in_unified_host,
bool update_mouse_location_now) {
bool in_first_edge = first_edge_bounds_in_native_.Contains(point_in_native);
bool in_second_edge = second_edge_bounds_in_native_.Contains(point_in_native);
if (!in_first_edge && !in_second_edge)
return false;
DisplayList display_list = Shell::GetInstance()
->display_manager()
->software_mirroring_display_list();
// Wait updating the cursor until the cursor moves to the new display
// to avoid showing the wrong sized cursor at the source display.
current_cursor_display_id_ =
in_first_edge ? display_list[0].id() : display_list[1].id();
AshWindowTreeHost* target_ash_host =
GetMirroringAshWindowTreeHostForDisplayId(
in_first_edge ? display_list[1].id() : display_list[0].id());
MoveCursorTo(target_ash_host, point_in_unified_host,
update_mouse_location_now);
return true;
}
} // namespace ash
|
