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
171
172
173
174
175
176
177
178
179
180
181
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/screen_util.h"
#include "ash/display/display_configuration_controller.h"
#include "ash/display/mirror_window_controller.h"
#include "ash/display/window_tree_host_manager.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/shelf/shelf.h"
#include "ash/shell.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/window_state.h"
#include "ash/wm/work_area_insets.h"
#include "base/check_op.h"
#include "ui/aura/client/screen_position_client.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_tree_host.h"
#include "ui/display/display.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/screen.h"
#include "ui/gfx/geometry/size_conversions.h"
#include "ui/wm/core/coordinate_conversion.h"
namespace ash {
namespace screen_util {
gfx::Rect GetMaximizedWindowBoundsInParent(aura::Window* window) {
if (Shelf::ForWindow(window)->shelf_widget())
return GetDisplayWorkAreaBoundsInParent(window);
return GetDisplayBoundsInParent(window);
}
gfx::Rect GetDisplayBoundsInParent(aura::Window* window) {
gfx::Rect result =
display::Screen::GetScreen()->GetDisplayNearestWindow(window).bounds();
::wm::ConvertRectFromScreen(window->parent(), &result);
return result;
}
gfx::Rect GetFullscreenWindowBoundsInParent(aura::Window* window) {
gfx::Rect result = GetDisplayBoundsInParent(window);
const WorkAreaInsets* const work_area_insets =
WorkAreaInsets::ForWindow(window->GetRootWindow());
result.Inset(
gfx::Insets().set_top(work_area_insets->accessibility_panel_height() +
work_area_insets->docked_magnifier_height()));
return result;
}
gfx::Rect GetDisplayWorkAreaBoundsInParent(aura::Window* window) {
// If it is application window under `non_lock_screen_containers`, use
// `in_session_user_work_area_insets`, otherwise, use `user_work_area_insets`.
const aura::Window* non_lock_screen_containers = Shell::GetContainer(
window->GetRootWindow(), kShellWindowId_NonLockScreenContainersContainer);
gfx::Insets insets =
non_lock_screen_containers->Contains(window)
? WorkAreaInsets::ForWindow(window)
->in_session_user_work_area_insets()
: WorkAreaInsets::ForWindow(window)->user_work_area_insets();
gfx::Rect bounds =
display::Screen::GetScreen()->GetDisplayNearestWindow(window).bounds();
bounds.Inset(insets);
::wm::ConvertRectFromScreen(window->parent(), &bounds);
return bounds;
}
// TODO(yongshun): Remove or consolidate this function with
// `GetDisplayWorkAreaBoundsInParent`.
gfx::Rect GetDisplayWorkAreaBoundsInParentForLockScreen(aura::Window* window) {
gfx::Rect bounds = WorkAreaInsets::ForWindow(window)->user_work_area_bounds();
::wm::ConvertRectFromScreen(window->parent(), &bounds);
return bounds;
}
// TODO(yongshun): Remove or consolidate this function with
// `GetDisplayWorkAreaBoundsInParent`.
gfx::Rect GetDisplayWorkAreaBoundsInParentForActiveDeskContainer(
aura::Window* window) {
aura::Window* root_window = window->GetRootWindow();
return GetDisplayWorkAreaBoundsInParent(
desks_util::GetActiveDeskContainerForRoot(root_window));
}
// TODO(yongshun): Remove or consolidate this function with
// `GetDisplayWorkAreaBoundsInParent`.
gfx::Rect GetDisplayWorkAreaBoundsInScreenForActiveDeskContainer(
aura::Window* window) {
gfx::Rect bounds =
GetDisplayWorkAreaBoundsInParentForActiveDeskContainer(window);
::wm::ConvertRectToScreen(window->GetRootWindow(), &bounds);
return bounds;
}
gfx::Rect GetDisplayBoundsWithShelf(aura::Window* window) {
if (!Shell::Get()->display_manager()->IsInUnifiedMode()) {
return display::Screen::GetScreen()
->GetDisplayNearestWindow(window)
.bounds();
}
// In Unified Mode, the display that should contain the shelf depends on the
// current shelf alignment.
const display::Display shelf_display =
Shell::Get()
->display_configuration_controller()
->GetPrimaryMirroringDisplayForUnifiedDesktop();
DCHECK_NE(shelf_display.id(), display::kInvalidDisplayId);
// Transform the bounds back to the unified host's coordinates.
auto inverse_unified_transform =
window->GetRootWindow()->GetHost()->GetInverseRootTransform();
return inverse_unified_transform.MapRect(shelf_display.bounds());
}
gfx::Rect SnapBoundsToDisplayEdge(const gfx::Rect& bounds,
const aura::Window* window) {
display::Display display =
display::Screen::GetScreen()->GetDisplayNearestWindow(
const_cast<aura::Window*>(window));
const float dsf = display.device_scale_factor();
const gfx::Size display_size_in_pixel = display.GetSizeInPixel();
const gfx::Size scaled_size_in_pixel =
gfx::ScaleToFlooredSize(display.size(), dsf);
// Adjusts |bounds| such that the scaled enclosed bounds are atleast as big as
// the scaled enclosing unadjusted bounds.
gfx::Rect snapped_bounds = bounds;
if (scaled_size_in_pixel.width() < display_size_in_pixel.width() &&
display.bounds().right() == bounds.right()) {
snapped_bounds.Inset(gfx::Insets::TLBR(0, 0, 0, -1));
DCHECK_GE(gfx::ScaleToEnclosedRect(snapped_bounds, dsf).right(),
gfx::ScaleToEnclosingRect(bounds, dsf).right());
}
if (scaled_size_in_pixel.height() < display_size_in_pixel.height() &&
display.bounds().bottom() == bounds.bottom()) {
snapped_bounds.Inset(gfx::Insets::TLBR(0, 0, -1, 0));
DCHECK_GE(gfx::ScaleToEnclosedRect(snapped_bounds, dsf).bottom(),
gfx::ScaleToEnclosingRect(bounds, dsf).bottom());
}
return snapped_bounds;
}
gfx::Rect GetIdealBoundsForMaximizedOrFullscreenOrPinnedState(
aura::Window* window) {
auto* window_state = WindowState::Get(window);
if (window_state->IsMaximized()) {
auto* shelf = ash::Shelf::ForWindow(window);
if (shelf->auto_hide_behavior() == ash::ShelfAutoHideBehavior::kAlways) {
gfx::Rect bounds =
ash::screen_util::GetFullscreenWindowBoundsInParent(window);
::wm::ConvertRectToScreen(window->parent(), &bounds);
return bounds;
}
if (shelf->auto_hide_behavior() ==
ash::ShelfAutoHideBehavior::kAlwaysHidden) {
return display::Screen::GetScreen()
->GetDisplayNearestWindow(const_cast<aura::Window*>(window))
.work_area();
}
auto work_area =
ash::WorkAreaInsets::ForWindow(window)->ComputeStableWorkArea();
return work_area;
}
if (window_state->IsFullscreen() || window_state->IsPinned()) {
gfx::Rect bounds =
ash::screen_util::GetFullscreenWindowBoundsInParent(window);
::wm::ConvertRectToScreen(window->parent(), &bounds);
return bounds;
}
NOTREACHED() << "The window is not maximzied or fullscreen or pinned. state="
<< window_state->GetStateType();
}
} // namespace screen_util
} // namespace ash
|
