| // 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 |
