// Copyright 2016 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/wm/window_positioning_utils.h"
#include <algorithm>
#include "ash/constants/ash_features.h"
#include "ash/display/display_util.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/root_window_controller.h"
#include "ash/screen_util.h"
#include "ash/shell.h"
#include "ash/wm/pip/pip_controller.h"
#include "ash/wm/system_modal_container_layout_manager.h"
#include "ash/wm/window_properties.h"
#include "ash/wm/window_restore/window_restore_controller.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "ash/wm/wm_event.h"
#include "base/notreached.h"
#include "base/numerics/ranges.h"
#include "components/app_restore/window_properties.h"
#include "ui/aura/client/focus_client.h"
#include "ui/aura/window.h"
#include "ui/aura/window_delegate.h"
#include "ui/aura/window_tracker.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/display/types/display_constants.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/wm/core/window_util.h"
namespace ash {
namespace {
int GetSnappedWindowAxisLength(float snap_ratio,
int work_area_axis_length,
int min_axis_length,
bool is_primary_snap) {
DCHECK_GT(snap_ratio, 0);
DCHECK_LE(snap_ratio, 1.f);
min_axis_length = std::min(min_axis_length, work_area_axis_length);
// The primary snap size is proportional to |snap_ratio|.
if (is_primary_snap) {
return std::clamp(static_cast<int>(snap_ratio * work_area_axis_length),
min_axis_length, work_area_axis_length);
}
// The secondary snap size is proportional to the |snap_ratio|, but
// we want to make sure there is no gap between the primary and secondary
// windows when their |snap_ratio|'s sum up to 1. Thus to avoid a gap from
// integer rounding up issue, we compute the empty-space size and subtracted
// it from |work_area_axis_length|. An example test is
// `WindowPositioningUtilsTest.SnapBoundsWithOddNumberedScreenWidth`.
const int empty_space_axis_length =
static_cast<int>((1 - snap_ratio) * work_area_axis_length);
return std::clamp(work_area_axis_length - empty_space_axis_length,
min_axis_length, work_area_axis_length);
}
// Return true if the window or one of its ancestor returns true from
// IsLockedToRoot().
bool IsWindowOrAncestorLockedToRoot(const aura::Window* window) {
return window && (window->GetProperty(kLockedToRootKey) ||
IsWindowOrAncestorLockedToRoot(window->parent()));
}
} // namespace
void AdjustBoundsSmallerThan(const gfx::Size& max_size, gfx::Rect* bounds) {
bounds->set_width(std::min(bounds->width(), max_size.width()));
bounds->set_height(std::min(bounds->height(), max_size.height()));
}
void AdjustBoundsToEnsureMinimumWindowVisibility(const gfx::Rect& visible_area,
bool client_controlled,
gfx::Rect* bounds) {
if (Shell::Get()->pip_controller()->is_tucked()) {
// PiP is allowed to be positioned beyond the threshold while it's tucked.
// TODO(http://b/337113950): Check if this is also needed for float windows.
return;
}
int min_width =
std::max(kMinimumOnScreenArea,
static_cast<int>(bounds->width() * kMinimumPercentOnScreenArea));
int min_height = std::max(
kMinimumOnScreenArea,
static_cast<int>(bounds->height() * kMinimumPercentOnScreenArea));
if (client_controlled) {
min_width++;
min_height++;
}
AdjustBoundsSmallerThan(visible_area.size(), bounds);
min_width = std::min(min_width, visible_area.width());
min_height = std::min(min_height, visible_area.height());
if (bounds->right() < visible_area.x() + min_width) {
bounds->set_x(visible_area.x() + std::min(bounds->width(), min_width) -
bounds->width());
} else if (bounds->x() > visible_area.right() - min_width) {
bounds->set_x(visible_area.right() - std::min(bounds->width(), min_width));
}
if (bounds->bottom() < visible_area.y() + min_height) {
bounds->set_y(visible_area.y() + std::min(bounds->height(), min_height) -
bounds->height());
} else if (bounds->y() > visible_area.bottom() - min_height) {
bounds->set_y(visible_area.bottom() -
std::min(bounds->height(), min_height));
}
if (bounds->y() < visible_area.y()) {
bounds->set_y(visible_area.y());
}
}
gfx::Rect GetSnappedWindowBoundsInParent(aura::Window* window,
SnapViewType type,
float snap_ratio) {
return GetSnappedWindowBounds(
screen_util::GetDisplayWorkAreaBoundsInParent(window),
display::Screen::GetScreen()->GetDisplayNearestWindow(window), window,
type, snap_ratio);
}
gfx::Rect GetDefaultSnappedWindowBoundsInParent(aura::Window* window,
SnapViewType type) {
return GetSnappedWindowBoundsInParent(window, type,
chromeos::kDefaultSnapRatio);
}
gfx::Rect GetSnappedWindowBounds(const gfx::Rect& work_area,
const display::Display display,
aura::Window* window,
SnapViewType type,
float snap_ratio) {
chromeos::OrientationType orientation = GetSnapDisplayOrientation(display);
enum class SnapRegion { kLeft, kRight, kBottom, kTop, kInvalid };
SnapRegion snap_region = SnapRegion::kInvalid;
const bool is_primary_snap = type == SnapViewType::kPrimary;
bool is_horizontal = true;
// Find the actual snap position that the `window` should be snapped to based
// on `orientation` and `type`.
switch (orientation) {
case chromeos::OrientationType::kLandscapePrimary:
snap_region = is_primary_snap ? SnapRegion::kLeft : SnapRegion::kRight;
break;
case chromeos::OrientationType::kLandscapeSecondary:
snap_region = is_primary_snap ? SnapRegion::kRight : SnapRegion::kLeft;
break;
case chromeos::OrientationType::kPortraitPrimary:
snap_region = is_primary_snap ? SnapRegion::kTop : SnapRegion::kBottom;
is_horizontal = false;
break;
case chromeos::OrientationType::kPortraitSecondary:
snap_region = is_primary_snap ? SnapRegion::kBottom : SnapRegion::kTop;
is_horizontal = false;
break;
default:
snap_region = SnapRegion::kInvalid;
NOTREACHED();
}
// Compute size of the side of the window bound that should be proportional
// |WindowState::snap_ratio_| to that of the work area, i.e. width for
// horizontal layout and height for vertical layout.
gfx::Rect snap_bounds = gfx::Rect(work_area);
const int work_area_axis_length =
is_horizontal ? work_area.width() : work_area.height();
int min_size = 0;
if (window->delegate()) {
const gfx::Size minimum_size = window->delegate()->GetMinimumSize();
min_size = is_horizontal ? minimum_size.width() : minimum_size.height();
}
int axis_length = GetSnappedWindowAxisLength(
snap_ratio, work_area_axis_length, min_size, is_primary_snap);
const gfx::Size* preferred_size =
window->GetProperty(kUnresizableSnappedSizeKey);
if (preferred_size && !WindowState::Get(window)->CanResize()) {
DCHECK(preferred_size->width() == 0 || preferred_size->height() == 0);
if (is_horizontal && preferred_size->width() > 0)
axis_length = preferred_size->width();
if (!is_horizontal && preferred_size->height() > 0)
axis_length = preferred_size->height();
} else if (window == WindowRestoreController::Get()->to_be_snapped_window()) {
// Edit `axis_length` if window restore is currently restoring a snapped
// window; take into account the snap percentage saved by the window.
app_restore::WindowInfo* window_info =
window->GetProperty(app_restore::kWindowInfoKey);
if (window_info && window_info->snap_percentage) {
const int snap_percentage = *window_info->snap_percentage;
axis_length = snap_percentage * work_area_axis_length / 100;
}
}
// Set the size of such side and the window position based on a given snap
// position.
switch (snap_region) {
case SnapRegion::kLeft:
snap_bounds.set_width(axis_length);
break;
case SnapRegion::kRight:
snap_bounds.set_width(axis_length);
// Snap to the right.
snap_bounds.set_x(work_area.right() - axis_length);
break;
case SnapRegion::kTop:
snap_bounds.set_height(axis_length);
break;
case SnapRegion::kBottom:
snap_bounds.set_height(axis_length);
// Snap to the bottom.
snap_bounds.set_y(work_area.bottom() - axis_length);
break;
case SnapRegion::kInvalid:
NOTREACHED();
}
return snap_bounds;
}
chromeos::OrientationType GetSnapDisplayOrientation(
const display::Display& display) {
// This function is used by `GetSnappedWindowBounds()` for clamshell mode
// only. Tablet mode uses a different function
// `SplitViewController::GetSnappedWindowBoundsInScreen()`.
DCHECK(!display::Screen::GetScreen()->InTabletMode());
const display::Display::Rotation& rotation =
Shell::Get()
->display_manager()
->GetDisplayInfo(display.id())
.GetActiveRotation();
return RotationToOrientation(chromeos::GetDisplayNaturalOrientation(display),
rotation);
}
void SetBoundsInScreen(aura::Window* window,
const gfx::Rect& bounds_in_screen,
const display::Display& display) {
// Don't move a window to other root window if:
// a) the window is a transient window. It moves when its
// transient parent moves.
// b) if the window or its ancestor has IsLockedToRoot(). It's intentionally
// kept in the same root window even if the bounds is outside of the
// display.
if (!::wm::GetTransientParent(window) &&
!IsWindowOrAncestorLockedToRoot(window)) {
RootWindowController* dst_root_window_controller =
Shell::GetRootWindowControllerWithDisplayId(display.id());
DCHECK(dst_root_window_controller);
aura::Window* dst_root = dst_root_window_controller->GetRootWindow();
DCHECK(dst_root);
aura::Window* dst_container = nullptr;
if (dst_root != window->GetRootWindow()) {
int container_id = window->parent()->GetId();
// All containers that use screen coordinates must have valid window ids.
DCHECK_GE(container_id, 0);
// Don't move modal background.
if (!SystemModalContainerLayoutManager::IsModalBackground(window))
dst_container = dst_root->GetChildById(container_id);
}
if (dst_container && window->parent() != dst_container) {
aura::Window* focused = window_util::GetFocusedWindow();
aura::Window* active = window_util::GetActiveWindow();
aura::WindowTracker tracker;
if (focused)
tracker.Add(focused);
if (active && focused != active)
tracker.Add(active);
// Client controlled window will have its own logic on client side
// to adjust bounds.
// TODO(oshima): Use WM_EVENT_SET_BOUNDS with target display id.
auto* window_state = WindowState::Get(window);
if (!window_state || !window_state->allow_set_bounds_direct()) {
gfx::Point origin = bounds_in_screen.origin();
const gfx::Point display_origin = display.bounds().origin();
origin.Offset(-display_origin.x(), -display_origin.y());
gfx::Rect new_bounds = gfx::Rect(origin, bounds_in_screen.size());
// Set new bounds now so that the container's layout manager can adjust
// the bounds if necessary.
if (window_state)
window_state->set_is_moving_to_another_display(true);
window->SetBounds(new_bounds);
}
dst_container->AddChild(window);
if (window_state)
window_state->set_is_moving_to_another_display(false);
// Restore focused/active window.
if (focused && tracker.Contains(focused)) {
aura::client::GetFocusClient(focused)->FocusWindow(focused);
Shell::SetRootWindowForNewWindows(focused->GetRootWindow());
} else if (active && tracker.Contains(active)) {
wm::ActivateWindow(active);
}
// TODO(oshima): We should not have to update the bounds again
// below in theory, but we currently do need as there is a code
// that assumes that the bounds will never be overridden by the
// layout mananger. We should have more explicit control how
// constraints are applied by the layout manager.
}
}
gfx::Point origin(bounds_in_screen.origin());
const gfx::Point display_origin = display::Screen::GetScreen()
->GetDisplayNearestWindow(window)
.bounds()
.origin();
origin.Offset(-display_origin.x(), -display_origin.y());
window->SetBounds(gfx::Rect(origin, bounds_in_screen.size()));
}
} // namespace ash
Codebase Browser
chromium