// Copyright 2017 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/keyboard/ui/container_floating_behavior.h"
#include <memory>
#include <optional>
#include "ash/keyboard/ui/display_util.h"
#include "ash/keyboard/ui/drag_descriptor.h"
#include "base/numerics/safe_conversions.h"
#include "ui/aura/window.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/display/display.h"
#include "ui/events/event.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/size.h"
#include "ui/wm/core/window_animations.h"
namespace keyboard {
// The virtual keyboard show/hide animation durations.
constexpr auto kShowAnimationDuration = base::Milliseconds(200);
constexpr auto kHideAnimationDuration = base::Milliseconds(100);
// Distance the keyboard moves during the animation
constexpr int kAnimationDistance = 30;
ContainerFloatingBehavior::ContainerFloatingBehavior(Delegate* delegate)
: ContainerBehavior(delegate) {}
ContainerFloatingBehavior::~ContainerFloatingBehavior() = default;
ContainerType ContainerFloatingBehavior::GetType() const {
return ContainerType::kFloating;
}
void ContainerFloatingBehavior::DoHidingAnimation(
aura::Window* container,
::wm::ScopedHidingAnimationSettings* animation_settings) {
animation_settings->layer_animation_settings()->SetTransitionDuration(
kHideAnimationDuration);
gfx::Transform transform;
transform.Translate(0, kAnimationDistance);
container->SetTransform(transform);
container->layer()->SetOpacity(0.f);
}
void ContainerFloatingBehavior::DoShowingAnimation(
aura::Window* container,
ui::ScopedLayerAnimationSettings* animation_settings) {
animation_settings->SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
animation_settings->SetTransitionDuration(kShowAnimationDuration);
container->SetTransform(gfx::Transform());
container->layer()->SetOpacity(1.0);
}
void ContainerFloatingBehavior::InitializeShowAnimationStartingState(
aura::Window* container) {
aura::Window* root_window = container->GetRootWindow();
SetCanonicalBounds(container, root_window->bounds());
gfx::Transform transform;
transform.Translate(0, kAnimationDistance);
container->SetTransform(transform);
container->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
}
gfx::Rect ContainerFloatingBehavior::AdjustSetBoundsRequest(
const gfx::Rect& display_bounds,
const gfx::Rect& requested_bounds_in_screen) {
gfx::Rect keyboard_bounds_in_screen = ContainKeyboardToDisplayBounds(
requested_bounds_in_screen, display_bounds);
SavePosition(keyboard_bounds_in_screen, display_bounds.size());
return keyboard_bounds_in_screen;
}
void ContainerFloatingBehavior::SavePosition(
const gfx::Rect& keyboard_bounds_in_screen,
const gfx::Size& screen_size) {
int left_distance = keyboard_bounds_in_screen.x();
int right_distance = screen_size.width() - keyboard_bounds_in_screen.right();
int top_distance = keyboard_bounds_in_screen.y();
int bottom_distance =
screen_size.height() - keyboard_bounds_in_screen.bottom();
double available_width = left_distance + right_distance;
double available_height = top_distance + bottom_distance;
if (!default_position_in_screen_) {
default_position_in_screen_ = std::make_unique<KeyboardPosition>();
}
default_position_in_screen_->left_padding_allotment_ratio =
left_distance / available_width;
default_position_in_screen_->top_padding_allotment_ratio =
top_distance / available_height;
}
gfx::Rect ContainerFloatingBehavior::ConvertAreaInKeyboardToScreenBounds(
const gfx::Rect& area_in_keyboard_window,
const gfx::Rect& keyboard_window_bounds_in_display) const {
gfx::Point origin_in_screen(
keyboard_window_bounds_in_display.x() + area_in_keyboard_window.x(),
keyboard_window_bounds_in_display.y() + area_in_keyboard_window.y());
return gfx::Rect(origin_in_screen, area_in_keyboard_window.size());
}
gfx::Rect ContainerFloatingBehavior::GetBoundsWithinDisplay(
const gfx::Rect& bounds,
const gfx::Rect& display_bounds) const {
gfx::Rect new_bounds = bounds;
if (bounds.x() < display_bounds.x()) {
new_bounds.set_origin(gfx::Point(display_bounds.x(), new_bounds.y()));
}
if (bounds.right() >= display_bounds.right()) {
new_bounds.set_origin(
gfx::Point(display_bounds.right() - bounds.width(), new_bounds.y()));
}
if (bounds.y() < display_bounds.y()) {
new_bounds.set_origin(gfx::Point(new_bounds.x(), display_bounds.y()));
}
if (bounds.bottom() >= display_bounds.bottom()) {
new_bounds.set_origin(gfx::Point(
new_bounds.x(), display_bounds.bottom() - new_bounds.height()));
}
return new_bounds;
}
gfx::Rect ContainerFloatingBehavior::ContainKeyboardToDisplayBounds(
const gfx::Rect& keyboard_window_bounds_in_screen,
const gfx::Rect& display_bounds) const {
if (!area_in_window_to_remain_on_screen_) {
return GetBoundsWithinDisplay(keyboard_window_bounds_in_screen,
display_bounds);
}
// This area is relative to the origin of the keyboard window not the
// screen.
gfx::Rect inner_area_of_keyboard_window =
*area_in_window_to_remain_on_screen_;
gfx::Rect area_to_remain_on_display = ConvertAreaInKeyboardToScreenBounds(
inner_area_of_keyboard_window, keyboard_window_bounds_in_screen);
gfx::Rect area_constrained_to_display =
GetBoundsWithinDisplay(area_to_remain_on_display, display_bounds);
// We need to calculate the new keyboard window bounds in this method,
// and at the moment we have constrained only an area inside the window
// to the display, not the entire keyboard window. So now we must
// derive the containing keyboard window bounds from this constrained
// inner area.
gfx::Point containing_keyboard_window_origin(
area_constrained_to_display.x() - inner_area_of_keyboard_window.x(),
area_constrained_to_display.y() - inner_area_of_keyboard_window.y());
return gfx::Rect(containing_keyboard_window_origin,
keyboard_window_bounds_in_screen.size());
}
bool ContainerFloatingBehavior::IsOverscrollAllowed() const {
return false;
}
gfx::Point ContainerFloatingBehavior::GetPositionForShowingKeyboard(
const gfx::Size& keyboard_size,
const gfx::Rect& display_bounds) const {
// Start with the last saved position
gfx::Point top_left_offset;
KeyboardPosition* position = default_position_in_screen_.get();
if (position == nullptr) {
// If there is none, center the keyboard along the bottom of the screen.
top_left_offset.set_x(display_bounds.width() - keyboard_size.width() -
kDefaultDistanceFromScreenRight);
top_left_offset.set_y(display_bounds.height() - keyboard_size.height() -
kDefaultDistanceFromScreenBottom);
} else {
double left = (display_bounds.width() - keyboard_size.width()) *
position->left_padding_allotment_ratio;
double top = (display_bounds.height() - keyboard_size.height()) *
position->top_padding_allotment_ratio;
top_left_offset.set_x(base::ClampFloor(left));
top_left_offset.set_y(base::ClampFloor(top));
}
// Make sure that this location is valid according to the current size of the
// screen.
gfx::Rect keyboard_bounds =
gfx::Rect(top_left_offset.x() + display_bounds.x(),
top_left_offset.y() + display_bounds.y(), keyboard_size.width(),
keyboard_size.height());
gfx::Rect valid_keyboard_bounds =
ContainKeyboardToDisplayBounds(keyboard_bounds, display_bounds);
return valid_keyboard_bounds.origin();
}
bool ContainerFloatingBehavior::HandlePointerEvent(
const ui::LocatedEvent& event,
const display::Display& current_display) {
const gfx::Vector2d kb_offset(base::ClampFloor(event.x()),
base::ClampFloor(event.y()));
const gfx::Rect& keyboard_bounds_in_screen = delegate_->GetBoundsInScreen();
// Don't handle events if this runs in a partially initialized state.
if (keyboard_bounds_in_screen.height() <= 0)
return false;
ui::PointerId pointer_id = ui::kPointerIdMouse;
if (event.IsTouchEvent()) {
const ui::TouchEvent* te = event.AsTouchEvent();
pointer_id = te->pointer_details().id;
}
const ui::EventType type = event.type();
switch (type) {
case ui::EventType::kTouchPressed:
case ui::EventType::kMousePressed:
if (!draggable_area_.Contains(kb_offset.x(), kb_offset.y())) {
drag_descriptor_.reset();
} else if (type == ui::EventType::kMousePressed &&
!static_cast<const ui::MouseEvent&>(event)
.IsOnlyLeftMouseButton()) {
// Mouse events are limited to just the left mouse button.
drag_descriptor_.reset();
} else if (!drag_descriptor_) {
drag_descriptor_ = std::make_unique<DragDescriptor>(DragDescriptor{
keyboard_bounds_in_screen.origin(), kb_offset, pointer_id});
}
break;
case ui::EventType::kMouseDragged:
case ui::EventType::kTouchMoved:
if (drag_descriptor_ && drag_descriptor_->pointer_id == pointer_id) {
// Drag continues.
// If there is an active drag, use it to determine the new location
// of the keyboard.
const gfx::Point original_click_location =
drag_descriptor_->original_keyboard_location +
drag_descriptor_->original_click_offset;
const gfx::Point current_drag_location =
keyboard_bounds_in_screen.origin() + kb_offset;
const gfx::Vector2d cumulative_drag_offset =
current_drag_location - original_click_location;
const gfx::Point new_keyboard_location =
drag_descriptor_->original_keyboard_location +
cumulative_drag_offset;
gfx::Rect new_bounds_in_local =
gfx::Rect(new_keyboard_location, keyboard_bounds_in_screen.size());
DisplayUtil display_util;
const display::Display& new_display =
display_util.FindAdjacentDisplayIfPointIsNearMargin(
current_display, current_drag_location);
if (current_display.id() == new_display.id()) {
delegate_->MoveKeyboardWindow(new_bounds_in_local);
} else {
// Since the keyboard has jumped across screens, cancel the current
// drag descriptor as though the user has lifted their finger.
drag_descriptor_.reset();
gfx::Rect new_bounds_in_screen =
new_bounds_in_local +
current_display.bounds().origin().OffsetFromOrigin();
gfx::Rect contained_new_bounds_in_screen =
ContainKeyboardToDisplayBounds(new_bounds_in_screen,
new_display.bounds());
// Enqueue a transition to the adjacent display.
new_bounds_in_local =
contained_new_bounds_in_screen -
new_display.bounds().origin().OffsetFromOrigin();
delegate_->MoveKeyboardWindowToDisplay(new_display,
new_bounds_in_local);
}
SavePosition(delegate_->GetBoundsInScreen(), new_display.size());
return true;
}
break;
default:
drag_descriptor_.reset();
break;
}
return false;
}
bool ContainerFloatingBehavior::HandleGestureEvent(
const ui::GestureEvent& event,
const gfx::Rect& bounds_in_screen) {
return false;
}
void ContainerFloatingBehavior::SetCanonicalBounds(
aura::Window* container,
const gfx::Rect& display_bounds) {
gfx::Point keyboard_location =
GetPositionForShowingKeyboard(container->bounds().size(), display_bounds);
gfx::Rect keyboard_bounds_in_screen =
gfx::Rect(keyboard_location, container->bounds().size());
SavePosition(keyboard_bounds_in_screen, display_bounds.size());
container->SetBounds(keyboard_bounds_in_screen);
}
bool ContainerFloatingBehavior::TextBlurHidesKeyboard() const {
return true;
}
gfx::Rect ContainerFloatingBehavior::GetOccludedBounds(
const gfx::Rect& visual_bounds_in_screen) const {
return {};
}
bool ContainerFloatingBehavior::OccludedBoundsAffectWorkspaceLayout() const {
return false;
}
void ContainerFloatingBehavior::SetDraggableArea(const gfx::Rect& rect) {
draggable_area_ = rect;
}
void ContainerFloatingBehavior::SetAreaToRemainOnScreen(const gfx::Rect& rect) {
area_in_window_to_remain_on_screen_ = rect;
}
} // namespace keyboard
Codebase Browser
chromium