| // Copyright 2013 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/wm/overview/overview_item.h" |
| |
| #include <algorithm> |
| #include <utility> |
| #include <vector> |
| |
| #include "ash/public/cpp/ash_features.h" |
| #include "ash/public/cpp/shell_window_ids.h" |
| #include "ash/public/cpp/window_properties.h" |
| #include "ash/resources/vector_icons/vector_icons.h" |
| #include "ash/scoped_animation_disabler.h" |
| #include "ash/shell.h" |
| #include "ash/strings/grit/ash_strings.h" |
| #include "ash/wm/overview/delayed_animation_observer_impl.h" |
| #include "ash/wm/overview/overview_animation_type.h" |
| #include "ash/wm/overview/overview_constants.h" |
| #include "ash/wm/overview/overview_controller.h" |
| #include "ash/wm/overview/overview_grid.h" |
| #include "ash/wm/overview/overview_utils.h" |
| #include "ash/wm/overview/overview_window_drag_controller.h" |
| #include "ash/wm/overview/rounded_label_widget.h" |
| #include "ash/wm/overview/scoped_overview_animation_settings.h" |
| #include "ash/wm/overview/scoped_overview_transform_window.h" |
| #include "ash/wm/splitview/split_view_constants.h" |
| #include "ash/wm/splitview/split_view_utils.h" |
| #include "ash/wm/tablet_mode/tablet_mode_controller.h" |
| #include "ash/wm/window_state.h" |
| #include "ash/wm/window_transient_descendant_iterator.h" |
| #include "ash/wm/wm_event.h" |
| #include "base/auto_reset.h" |
| #include "base/metrics/user_metrics.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/compositor/layer_animation_sequence.h" |
| #include "ui/compositor/scoped_animation_duration_scale_mode.h" |
| #include "ui/compositor/scoped_layer_animation_settings.h" |
| #include "ui/compositor_extra/shadow.h" |
| #include "ui/gfx/geometry/safe_integer_conversions.h" |
| #include "ui/gfx/paint_vector_icon.h" |
| #include "ui/strings/grit/ui_strings.h" |
| #include "ui/views/animation/flood_fill_ink_drop_ripple.h" |
| #include "ui/views/animation/ink_drop_impl.h" |
| #include "ui/views/animation/ink_drop_mask.h" |
| #include "ui/views/controls/button/image_button.h" |
| #include "ui/views/widget/widget.h" |
| #include "ui/wm/core/coordinate_conversion.h" |
| #include "ui/wm/core/shadow_types.h" |
| #include "ui/wm/core/window_util.h" |
| |
| namespace ash { |
| |
| namespace { |
| |
| // Opacity for fading out during closing a window. |
| constexpr float kClosingItemOpacity = 0.8f; |
| |
| // Opacity for the item header. |
| constexpr float kHeaderOpacity = 0.1f; |
| |
| // Before closing a window animate both the window and the caption to shrink by |
| // this fraction of size. |
| constexpr float kPreCloseScale = 0.02f; |
| |
| constexpr int kShadowElevation = 16; |
| |
| // The amount of translation an item animates by when it is closed by using |
| // swipe to close. |
| constexpr int kSwipeToCloseCloseTranslationDp = 96; |
| |
| // When an item is being dragged, the bounds are outset horizontally by this |
| // fraction of the width, and vertically by this fraction of the height. The |
| // outset in each dimension is on both sides, for a total of twice this much |
| // change in the size of the item along that dimension. |
| constexpr float kDragWindowScale = 0.05f; |
| |
| constexpr int kCloseButtonInkDropInsetDp = 2; |
| |
| constexpr SkColor kCloseButtonColor = SK_ColorWHITE; |
| |
| // The colors of the close button ripple. |
| constexpr SkColor kCloseButtonInkDropRippleColor = |
| SkColorSetA(kCloseButtonColor, 0x0F); |
| constexpr SkColor kCloseButtonInkDropRippleHighlightColor = |
| SkColorSetA(kCloseButtonColor, 0x14); |
| |
| OverviewAnimationType GetExitOverviewAnimationTypeForMinimizedWindow( |
| OverviewSession::EnterExitOverviewType type, |
| bool should_animate_when_exiting) { |
| // We should never get here when overview mode should exit immediately. The |
| // minimized window's |item_widget_| should be closed and destroyed |
| // immediately. |
| DCHECK_NE(type, OverviewSession::EnterExitOverviewType::kImmediateExit); |
| |
| // EnterExitOverviewType can only be set to kWindowMinimized in talbet mode. |
| // Fade out the minimized window without animation if switch from tablet mode |
| // to clamshell mode. |
| if (type == OverviewSession::EnterExitOverviewType::kWindowsMinimized) { |
| return Shell::Get() |
| ->tablet_mode_controller() |
| ->IsTabletModeWindowManagerEnabled() |
| ? OVERVIEW_ANIMATION_EXIT_TO_HOME_LAUNCHER |
| : OVERVIEW_ANIMATION_NONE; |
| } |
| return should_animate_when_exiting |
| ? OVERVIEW_ANIMATION_EXIT_OVERVIEW_MODE_FADE_OUT |
| : OVERVIEW_ANIMATION_RESTORE_WINDOW_ZERO; |
| } |
| |
| // Applies |new_bounds| to |widget|, animating and observing the transform if |
| // necessary. |
| void SetWidgetBoundsAndMaybeAnimateTransform( |
| views::Widget* widget, |
| const gfx::Rect& new_bounds, |
| OverviewAnimationType animation_type, |
| ui::ImplicitAnimationObserver* observer) { |
| aura::Window* window = widget->GetNativeWindow(); |
| gfx::RectF previous_bounds = gfx::RectF(window->GetBoundsInScreen()); |
| window->SetBounds(new_bounds); |
| if (animation_type == OVERVIEW_ANIMATION_NONE) |
| return; |
| |
| // For animations, compute the transform needed to place the widget at its |
| // new bounds back to the old bounds, and then apply the idenity |
| // transform. This so the bounds visually line up the concurrent transform |
| // animations. Also transform animations may be more performant. |
| // TODO(sammiequon): Move the transform calcuations to a utility function. |
| gfx::RectF current_bounds = gfx::RectF(window->GetBoundsInScreen()); |
| gfx::Transform transform(previous_bounds.width() / current_bounds.width(), |
| 0.f, 0.f, |
| previous_bounds.height() / current_bounds.height(), |
| previous_bounds.x() - current_bounds.x(), |
| previous_bounds.y() - current_bounds.y()); |
| window->SetTransform(transform); |
| ScopedOverviewAnimationSettings settings(animation_type, window); |
| if (observer) |
| settings.AddObserver(observer); |
| window->SetTransform(gfx::Transform()); |
| } |
| |
| } // namespace |
| |
| // The class to cache render surface to the specified window's layer. |
| class OverviewItem::WindowSurfaceCacheObserver : public aura::WindowObserver { |
| public: |
| explicit WindowSurfaceCacheObserver(aura::Window* window) { |
| StartObserving(window); |
| } |
| |
| ~WindowSurfaceCacheObserver() override { StopObserving(); } |
| |
| void StartObserving(aura::Window* window) { |
| // If we're already observing a window, stop observing it first. |
| StopObserving(); |
| |
| window_ = window; |
| window_->AddObserver(this); |
| window_->layer()->AddCacheRenderSurfaceRequest(); |
| } |
| |
| // aura::WindowObserver: |
| void OnWindowDestroying(aura::Window* window) override { |
| DCHECK_EQ(window_, window); |
| StopObserving(); |
| } |
| |
| private: |
| void StopObserving() { |
| if (window_) { |
| window_->layer()->RemoveCacheRenderSurfaceRequest(); |
| window_->RemoveObserver(this); |
| window_ = nullptr; |
| } |
| } |
| |
| aura::Window* window_ = nullptr; |
| DISALLOW_COPY_AND_ASSIGN(WindowSurfaceCacheObserver); |
| }; |
| |
| // The close button for the overview item. It has a custom ink drop. |
| class OverviewItem::OverviewCloseButton : public views::ImageButton { |
| public: |
| explicit OverviewCloseButton(views::ButtonListener* listener) |
| : views::ImageButton(listener) { |
| SetInkDropMode(InkDropMode::ON_NO_GESTURE_HANDLER); |
| SetImage( |
| views::Button::STATE_NORMAL, |
| gfx::CreateVectorIcon(kOverviewWindowCloseIcon, kCloseButtonColor)); |
| SetImageHorizontalAlignment(views::ImageButton::ALIGN_CENTER); |
| SetImageVerticalAlignment(views::ImageButton::ALIGN_MIDDLE); |
| SetMinimumImageSize(gfx::Size(kHeaderHeightDp, kHeaderHeightDp)); |
| SetAccessibleName(l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE)); |
| SetTooltipText(l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE)); |
| } |
| |
| ~OverviewCloseButton() override = default; |
| |
| // Resets the listener so that the listener can go out of scope. |
| void ResetListener() { listener_ = nullptr; } |
| |
| protected: |
| // views::Button: |
| std::unique_ptr<views::InkDrop> CreateInkDrop() override { |
| auto ink_drop = std::make_unique<views::InkDropImpl>(this, size()); |
| ink_drop->SetAutoHighlightMode( |
| views::InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE); |
| ink_drop->SetShowHighlightOnHover(true); |
| return ink_drop; |
| } |
| std::unique_ptr<views::InkDropRipple> CreateInkDropRipple() const override { |
| return std::make_unique<views::FloodFillInkDropRipple>( |
| size(), gfx::Insets(), GetInkDropCenterBasedOnLastEvent(), |
| kCloseButtonInkDropRippleColor, /*visible_opacity=*/1.f); |
| } |
| std::unique_ptr<views::InkDropHighlight> CreateInkDropHighlight() |
| const override { |
| return std::make_unique<views::InkDropHighlight>( |
| gfx::PointF(GetLocalBounds().CenterPoint()), |
| std::make_unique<views::CircleLayerDelegate>( |
| kCloseButtonInkDropRippleHighlightColor, GetInkDropRadius())); |
| } |
| std::unique_ptr<views::InkDropMask> CreateInkDropMask() const override { |
| return std::make_unique<views::CircleInkDropMask>( |
| size(), GetLocalBounds().CenterPoint(), GetInkDropRadius()); |
| } |
| |
| private: |
| int GetInkDropRadius() const { |
| return std::min(size().width(), size().height()) / 2 - |
| kCloseButtonInkDropInsetDp; |
| } |
| |
| DISALLOW_COPY_AND_ASSIGN(OverviewCloseButton); |
| }; |
| |
| OverviewItem::OverviewItem(aura::Window* window, |
| OverviewSession* overview_session, |
| OverviewGrid* overview_grid) |
| : root_window_(window->GetRootWindow()), |
| transform_window_(this, window), |
| overview_session_(overview_session), |
| overview_grid_(overview_grid) { |
| CreateWindowLabel(); |
| for (auto* window_iter : wm::WindowTransientDescendantIteratorRange( |
| wm::WindowTransientDescendantIterator(GetWindow()))) { |
| window_iter->AddObserver(this); |
| } |
| } |
| |
| OverviewItem::~OverviewItem() { |
| for (auto* window_iter : wm::WindowTransientDescendantIteratorRange( |
| wm::WindowTransientDescendantIterator(GetWindow()))) { |
| window_iter->RemoveObserver(this); |
| } |
| } |
| |
| aura::Window* OverviewItem::GetWindow() { |
| return transform_window_.window(); |
| } |
| |
| bool OverviewItem::Contains(const aura::Window* target) const { |
| return transform_window_.Contains(target); |
| } |
| |
| void OverviewItem::RestoreWindow(bool reset_transform) { |
| // TODO(oshima): SplitViewController has its own logic to adjust the |
| // target state in |SplitViewController::OnOverviewModeEnding|. |
| // Unify the mechanism to control it and remove ifs. |
| if (Shell::Get() |
| ->tablet_mode_controller() |
| ->IsTabletModeWindowManagerEnabled() && |
| !Shell::Get()->split_view_controller()->InSplitViewMode() && |
| reset_transform) { |
| MaximizeIfSnapped(GetWindow()); |
| } |
| |
| caption_container_view_->ResetEventDelegate(); |
| close_button_->ResetListener(); |
| transform_window_.RestoreWindow(reset_transform); |
| |
| if (transform_window_.IsMinimized()) { |
| const auto enter_exit_type = overview_session_->enter_exit_overview_type(); |
| |
| if (enter_exit_type == |
| OverviewSession::EnterExitOverviewType::kImmediateExit) { |
| ImmediatelyCloseWidgetOnExit(std::move(item_widget_)); |
| return; |
| } |
| |
| FadeOutWidgetAndMaybeSlideOnExit( |
| std::move(item_widget_), |
| GetExitOverviewAnimationTypeForMinimizedWindow( |
| enter_exit_type, should_animate_when_exiting_)); |
| } |
| } |
| |
| void OverviewItem::EnsureVisible() { |
| transform_window_.EnsureVisible(); |
| } |
| |
| void OverviewItem::Shutdown() { |
| item_widget_.reset(); |
| } |
| |
| void OverviewItem::PrepareForOverview() { |
| transform_window_.PrepareForOverview(); |
| aura::Window* widget_window = item_widget_->GetNativeWindow(); |
| widget_window->parent()->StackChildBelow(widget_window, GetWindow()); |
| } |
| |
| void OverviewItem::SlideWindowIn() { |
| // This only gets called if we see the home launcher on enter (all windows are |
| // minimized). |
| DCHECK(transform_window_.IsMinimized()); |
| |
| // The mask and shadow will be shown when animation ends. Update the mask |
| // after starting the animation since starting the animation lets the |
| // controller know we are in starting animation. |
| FadeInWidgetAndMaybeSlideOnEnter(item_widget_.get(), |
| OVERVIEW_ANIMATION_ENTER_FROM_HOME_LAUNCHER, |
| /*slide=*/true, /*observe=*/true); |
| UpdateMaskAndShadow(); |
| } |
| |
| std::unique_ptr<ui::ScopedLayerAnimationSettings> |
| OverviewItem::UpdateYPositionAndOpacity( |
| int new_grid_y, |
| float opacity, |
| OverviewSession::UpdateAnimationSettingsCallback callback) { |
| aura::Window::Windows windows = GetWindowsForHomeGesture(); |
| std::unique_ptr<ui::ScopedLayerAnimationSettings> settings_to_observe; |
| for (auto* window : windows) { |
| ui::Layer* layer = window->layer(); |
| std::unique_ptr<ui::ScopedLayerAnimationSettings> settings; |
| if (!callback.is_null()) { |
| settings = std::make_unique<ui::ScopedLayerAnimationSettings>( |
| layer->GetAnimator()); |
| callback.Run(settings.get()); |
| } |
| layer->SetOpacity(opacity); |
| |
| int initial_y_ = 0; |
| if (translation_y_map_.contains(window)) |
| initial_y_ = translation_y_map_[window]; |
| |
| // Alter the y-translation. Offset by the window location relative to the |
| // grid. |
| gfx::Transform transform = layer->transform(); |
| transform.matrix().setFloat(1, 3, |
| static_cast<float>(initial_y_ - new_grid_y)); |
| layer->SetTransform(transform); |
| |
| // Return the first layer for the caller to observe. |
| if (!settings_to_observe) |
| settings_to_observe = std::move(settings); |
| } |
| |
| return settings_to_observe; |
| } |
| |
| void OverviewItem::UpdateItemContentViewForMinimizedWindow() { |
| caption_container_view_->UpdatePreviewView(); |
| } |
| |
| float OverviewItem::GetItemScale(const gfx::Size& size) { |
| gfx::SizeF inset_size(size.width(), size.height() - 2 * kWindowMargin); |
| return ScopedOverviewTransformWindow::GetItemScale( |
| GetTargetBoundsInScreen().size(), inset_size, |
| transform_window_.GetTopInset(), kHeaderHeightDp); |
| } |
| |
| gfx::RectF OverviewItem::GetTargetBoundsInScreen() const { |
| return ::ash::GetTargetBoundsInScreen(transform_window_.window()); |
| } |
| |
| gfx::RectF OverviewItem::GetTransformedBounds() const { |
| return transform_window_.GetTransformedBounds(); |
| } |
| |
| void OverviewItem::SetBounds(const gfx::RectF& target_bounds, |
| OverviewAnimationType animation_type) { |
| if (in_bounds_update_ || |
| !Shell::Get()->overview_controller()->InOverviewSession()) |
| return; |
| |
| // Do not animate if the resulting bounds does not change. The original |
| // window may change bounds so we still need to call SetItemBounds to update |
| // the window transform. |
| OverviewAnimationType new_animation_type = animation_type; |
| if (target_bounds == target_bounds_ && |
| !GetWindow()->layer()->GetAnimator()->is_animating()) { |
| new_animation_type = OVERVIEW_ANIMATION_NONE; |
| } |
| |
| base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true); |
| // If |target_bounds_| is empty, this is the first update. Let |
| // UpdateHeaderLayout know, as we do not want |item_widget_| to be animated |
| // with the window. |
| const bool is_first_update = target_bounds_.IsEmpty(); |
| target_bounds_ = target_bounds; |
| |
| gfx::RectF inset_bounds(target_bounds); |
| inset_bounds.Inset(kWindowMargin, kWindowMargin); |
| |
| // If the window is minimized we can avoid applying transforms on the original |
| // window. |
| if (transform_window_.IsMinimized()) { |
| item_widget_->GetNativeWindow()->layer()->GetAnimator()->StopAnimating(); |
| |
| gfx::Rect minimized_bounds = gfx::ToEnclosedRect(target_bounds); |
| minimized_bounds.Inset(-kWindowMargin, -kWindowMargin); |
| OverviewAnimationType minimized_animation_type = |
| is_first_update ? OVERVIEW_ANIMATION_NONE : new_animation_type; |
| SetWidgetBoundsAndMaybeAnimateTransform( |
| item_widget_.get(), minimized_bounds, minimized_animation_type, |
| minimized_animation_type == |
| OVERVIEW_ANIMATION_LAYOUT_OVERVIEW_ITEMS_IN_OVERVIEW |
| ? &transform_window_ |
| : nullptr); |
| |
| // On the first update show |item_widget_|. It's created on creation of |
| // |this|, and needs to be shown as soon as its bounds have been determined |
| // as it contains a mirror view of the window in its contents. The header |
| // will be faded in later to match non minimized windows. |
| if (is_first_update) { |
| if (should_animate_when_entering_) { |
| FadeInWidgetAndMaybeSlideOnEnter( |
| item_widget_.get(), OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN, |
| /*slide=*/false, /*observe=*/true); |
| } else { |
| item_widget_->GetNativeWindow()->layer()->SetOpacity(1.f); |
| } |
| } |
| } else { |
| // SetItemBounds is called before UpdateHeaderLayout so the header can |
| // properly use the updated windows bounds. |
| SetItemBounds(inset_bounds, new_animation_type); |
| UpdateHeaderLayout(is_first_update ? OVERVIEW_ANIMATION_NONE |
| : new_animation_type); |
| } |
| |
| // Shadow is normally set after an animation is finished. In the case of no |
| // animations, manually set the shadow. Shadow relies on both the window |
| // transform and |item_widget_|'s new bounds so set it after SetItemBounds |
| // and UpdateHeaderLayout. Do not apply the shadow for drop target. |
| if (new_animation_type == OVERVIEW_ANIMATION_NONE) |
| UpdateMaskAndShadow(); |
| |
| if (cannot_snap_widget_) { |
| inset_bounds.Inset( |
| gfx::Insets(static_cast<float>(kHeaderHeightDp), 0.f, 0.f, 0.f)); |
| SetWidgetBoundsAndMaybeAnimateTransform( |
| cannot_snap_widget_.get(), |
| cannot_snap_widget_->GetBoundsCenteredIn( |
| gfx::ToEnclosingRect(inset_bounds)), |
| new_animation_type, nullptr); |
| } |
| |
| translation_y_map_.clear(); |
| aura::Window::Windows windows = GetWindowsForHomeGesture(); |
| for (auto* window : windows) { |
| // There is a bug where the first OverviewItem |window_| will always return |
| // the identity, even though a transform has been visually applied. For this |
| // case use the y location of the screen bounds. |
| // TODO(sammiequon): Investigate why this is happening and remove the if |
| // clause. |
| if (window->transform().IsIdentity() && |
| (window == GetWindow() || |
| ::wm::HasTransientAncestor(window, GetWindow()))) { |
| translation_y_map_[window] = window->GetBoundsInScreen().y(); |
| } else { |
| translation_y_map_[window] = window->transform().To2dTranslation().y(); |
| } |
| } |
| } |
| |
| void OverviewItem::SendAccessibleSelectionEvent() { |
| caption_container_view_->NotifyAccessibilityEvent( |
| ax::mojom::Event::kSelection, true); |
| } |
| |
| void OverviewItem::AnimateAndCloseWindow(bool up) { |
| base::RecordAction(base::UserMetricsAction("WindowSelector_SwipeToClose")); |
| |
| animating_to_close_ = true; |
| overview_session_->PositionWindows(/*animate=*/true); |
| caption_container_view_->ResetEventDelegate(); |
| close_button_->ResetListener(); |
| |
| int translation_y = kSwipeToCloseCloseTranslationDp * (up ? -1 : 1); |
| gfx::Transform transform; |
| transform.Translate(gfx::Vector2d(0, translation_y)); |
| |
| auto animate_window = [this](aura::Window* window, |
| const gfx::Transform& transform, bool observe) { |
| ScopedOverviewAnimationSettings settings( |
| OVERVIEW_ANIMATION_CLOSE_OVERVIEW_ITEM, window); |
| gfx::Transform original_transform = window->transform(); |
| original_transform.ConcatTransform(transform); |
| window->SetTransform(original_transform); |
| if (observe) |
| settings.AddObserver(this); |
| }; |
| |
| AnimateOpacity(0.0, OVERVIEW_ANIMATION_CLOSE_OVERVIEW_ITEM); |
| if (cannot_snap_widget_) |
| animate_window(cannot_snap_widget_->GetNativeWindow(), transform, false); |
| if (!transform_window_.IsMinimized()) |
| animate_window(GetWindow(), transform, false); |
| animate_window(item_widget_->GetNativeWindow(), transform, true); |
| } |
| |
| void OverviewItem::CloseWindow() { |
| gfx::RectF inset_bounds(target_bounds_); |
| inset_bounds.Inset(target_bounds_.width() * kPreCloseScale, |
| target_bounds_.height() * kPreCloseScale); |
| // Scale down both the window and label. |
| SetBounds(inset_bounds, OVERVIEW_ANIMATION_CLOSING_OVERVIEW_ITEM); |
| // First animate opacity to an intermediate value concurrently with the |
| // scaling animation. |
| AnimateOpacity(kClosingItemOpacity, OVERVIEW_ANIMATION_CLOSING_OVERVIEW_ITEM); |
| |
| // Fade out the window and the label, effectively hiding them. |
| AnimateOpacity(0.0, OVERVIEW_ANIMATION_CLOSE_OVERVIEW_ITEM); |
| transform_window_.Close(); |
| } |
| |
| void OverviewItem::OnMinimizedStateChanged() { |
| const bool minimized = transform_window_.IsMinimized(); |
| caption_container_view_->SetShowPreview(minimized); |
| if (minimized) |
| EnsureVisible(); |
| |
| if (window_surface_cache_observers_) { |
| window_surface_cache_observers_->StartObserving( |
| transform_window_.GetOverviewWindow()); |
| } |
| } |
| |
| void OverviewItem::UpdateCannotSnapWarningVisibility() { |
| // Windows which can snap will never show this warning. Or if the window is |
| // the drop target window, also do not show this warning. |
| bool visible = true; |
| if (CanSnapInSplitview(GetWindow()) || |
| overview_grid_->IsDropTargetWindow(GetWindow())) { |
| visible = false; |
| } else { |
| const SplitViewState state = Shell::Get()->split_view_controller()->state(); |
| visible = state == SplitViewState::kLeftSnapped || |
| state == SplitViewState::kRightSnapped; |
| } |
| |
| if (!visible && !cannot_snap_widget_) |
| return; |
| |
| if (!cannot_snap_widget_) { |
| RoundedLabelWidget::InitParams params; |
| params.horizontal_padding = kSplitviewLabelHorizontalInsetDp; |
| params.vertical_padding = kSplitviewLabelVerticalInsetDp; |
| params.background_color = kSplitviewLabelBackgroundColor; |
| params.foreground_color = kSplitviewLabelEnabledColor; |
| params.rounding_dp = kSplitviewLabelRoundRectRadiusDp; |
| params.preferred_height = kSplitviewLabelPreferredHeightDp; |
| params.message_id = IDS_ASH_SPLIT_VIEW_CANNOT_SNAP; |
| params.parent = |
| root_window()->GetChildById(kShellWindowId_AlwaysOnTopContainer); |
| cannot_snap_widget_ = std::make_unique<RoundedLabelWidget>(); |
| cannot_snap_widget_->Init(params); |
| auto* widget_window = cannot_snap_widget_->GetNativeWindow(); |
| widget_window->SetProperty(kHideInDeskMiniViewKey, true); |
| } |
| |
| DoSplitviewOpacityAnimation(cannot_snap_widget_->GetNativeWindow()->layer(), |
| visible |
| ? SPLITVIEW_ANIMATION_OVERVIEW_ITEM_FADE_IN |
| : SPLITVIEW_ANIMATION_OVERVIEW_ITEM_FADE_OUT); |
| gfx::Rect bounds = gfx::ToEnclosingRect(target_bounds()); |
| bounds.Inset(kWindowMargin, kWindowMargin); |
| bounds.Inset(gfx::Insets(kHeaderHeightDp, 0, 0, 0)); |
| cannot_snap_widget_->SetBoundsCenteredIn(bounds); |
| } |
| |
| void OverviewItem::OnSelectorItemDragStarted(OverviewItem* item) { |
| is_being_dragged_ = (item == this); |
| // Disable mask and shadow for the dragged overview item during dragging. |
| if (is_being_dragged_) |
| UpdateMaskAndShadow(); |
| |
| caption_container_view_->SetHeaderVisibility( |
| is_being_dragged_ |
| ? CaptionContainerView::HeaderVisibility::kInvisible |
| : CaptionContainerView::HeaderVisibility::kCloseButtonInvisibleOnly); |
| |
| if (!features::ShouldUseShaderRoundedCorner()) { |
| // Start caching render surface during overview window dragging. |
| window_surface_cache_observers_ = |
| std::make_unique<WindowSurfaceCacheObserver>( |
| transform_window_.GetOverviewWindow()); |
| } |
| } |
| |
| void OverviewItem::OnSelectorItemDragEnded(bool snap) { |
| // Stop caching render surface after overview window dragging. |
| window_surface_cache_observers_.reset(); |
| |
| if (is_being_dragged_) { |
| is_being_dragged_ = false; |
| // Do nothing further with the dragged overview item if it is being snapped. |
| if (snap) |
| return; |
| // Re-show mask and shadow for the dragged overview item after drag ends. |
| UpdateMaskAndShadow(); |
| } |
| |
| // Update the header. |
| if (snap) { |
| caption_container_view_->HideCloseInstantlyAndThenShowItSlowly(); |
| } else { |
| caption_container_view_->SetHeaderVisibility( |
| CaptionContainerView::HeaderVisibility::kVisible); |
| } |
| } |
| |
| ScopedOverviewTransformWindow::GridWindowFillMode |
| OverviewItem::GetWindowDimensionsType() const { |
| return transform_window_.type(); |
| } |
| |
| void OverviewItem::UpdateWindowDimensionsType() { |
| transform_window_.UpdateWindowDimensionsType(); |
| const bool show_backdrop = |
| GetWindowDimensionsType() != |
| ScopedOverviewTransformWindow::GridWindowFillMode::kNormal; |
| caption_container_view_->SetBackdropVisibility(show_backdrop); |
| } |
| |
| gfx::Rect OverviewItem::GetBoundsOfSelectedItem() { |
| gfx::RectF original_bounds = target_bounds(); |
| ScaleUpSelectedItem(OVERVIEW_ANIMATION_NONE); |
| gfx::RectF selected_bounds = transform_window_.GetTransformedBounds(); |
| SetBounds(original_bounds, OVERVIEW_ANIMATION_NONE); |
| return gfx::ToEnclosedRect(selected_bounds); |
| } |
| |
| void OverviewItem::ScaleUpSelectedItem(OverviewAnimationType animation_type) { |
| gfx::RectF scaled_bounds = target_bounds(); |
| scaled_bounds.Inset(-scaled_bounds.width() * kDragWindowScale, |
| -scaled_bounds.height() * kDragWindowScale); |
| SetBounds(scaled_bounds, animation_type); |
| } |
| |
| bool OverviewItem::IsDragItem() { |
| return overview_session_->window_drag_controller() && |
| overview_session_->window_drag_controller()->item() == this; |
| } |
| |
| void OverviewItem::OnDragAnimationCompleted() { |
| // This is function is called whenever the grid repositions its windows, but |
| // we only need to restack the windows if an item was being dragged around |
| // and then released. |
| if (!should_restack_on_animation_end_) |
| return; |
| |
| should_restack_on_animation_end_ = false; |
| |
| // First stack this item's window below the snapped window if split view mode |
| // is active. |
| aura::Window* dragged_window = GetWindow(); |
| aura::Window* dragged_widget_window = item_widget_->GetNativeWindow(); |
| aura::Window* parent_window = dragged_widget_window->parent(); |
| if (Shell::Get()->split_view_controller()->InSplitViewMode()) { |
| aura::Window* snapped_window = |
| Shell::Get()->split_view_controller()->GetDefaultSnappedWindow(); |
| if (snapped_window->parent() == parent_window && |
| dragged_window->parent() == parent_window) { |
| parent_window->StackChildBelow(dragged_window, snapped_window); |
| parent_window->StackChildBelow(dragged_widget_window, dragged_window); |
| } |
| } |
| |
| // Then find the window which was stacked right above this overview item's |
| // window before dragging and stack this overview item's window below it. |
| const std::vector<std::unique_ptr<OverviewItem>>& overview_items = |
| overview_grid_->window_list(); |
| aura::Window* stacking_target = nullptr; |
| for (size_t index = 0; index < overview_items.size(); ++index) { |
| if (index > 0) { |
| aura::Window* window = overview_items[index - 1].get()->GetWindow(); |
| if (window->parent() == parent_window && |
| dragged_window->parent() == parent_window) { |
| stacking_target = |
| overview_items[index - 1].get()->item_widget()->GetNativeWindow(); |
| } |
| } |
| if (overview_items[index].get() == this && stacking_target) { |
| parent_window->StackChildBelow(dragged_window, stacking_target); |
| parent_window->StackChildBelow(dragged_widget_window, dragged_window); |
| break; |
| } |
| } |
| } |
| |
| void OverviewItem::SetShadowBounds(base::Optional<gfx::Rect> bounds_in_screen) { |
| // Shadow is normally turned off during animations and reapplied when they |
| // are finished. On destruction, |shadow_| is cleaned up before |
| // |transform_window_|, which may call this function, so early exit if |
| // |shadow_| is nullptr. |
| if (!shadow_) |
| return; |
| |
| if (bounds_in_screen == base::nullopt) { |
| shadow_->layer()->SetVisible(false); |
| return; |
| } |
| |
| shadow_->layer()->SetVisible(true); |
| gfx::Rect bounds_in_item = |
| gfx::Rect(item_widget_->GetNativeWindow()->GetTargetBounds().size()); |
| bounds_in_item.Inset(kOverviewMargin, kOverviewMargin); |
| bounds_in_item.Inset(0, kHeaderHeightDp, 0, 0); |
| bounds_in_item.ClampToCenteredSize(bounds_in_screen.value().size()); |
| |
| shadow_->SetContentBounds(bounds_in_item); |
| } |
| |
| void OverviewItem::UpdateMaskAndShadow() { |
| // Do not show mask and shadow if: |
| // 1) overview is shutting down or |
| // 2) this overview item is in an overview grid that contains more than 10 |
| // windows. In this case don't apply rounded corner mask because it can |
| // push the compositor memory usage to the limit. TODO(oshima): Remove |
| // this once new rounded corner impl is available. (crbug.com/903486) |
| // 3) we're currently in entering overview animation or |
| // 4) this overview item is being dragged or |
| // 5) this overview item is the drop target window or |
| // 6) this overview item is in animation. |
| bool should_show = true; |
| OverviewController* overview_controller = Shell::Get()->overview_controller(); |
| if (disable_mask_ || !overview_controller || |
| !overview_controller->InOverviewSession() || |
| (!ash::features::ShouldUseShaderRoundedCorner() && |
| overview_grid_->window_list().size() > 10) || |
| overview_controller->IsInStartAnimation() || is_being_dragged_ || |
| overview_grid_->IsDropTargetWindow(GetWindow()) || |
| transform_window_.GetOverviewWindow() |
| ->layer() |
| ->GetAnimator() |
| ->is_animating()) { |
| should_show = false; |
| } |
| |
| transform_window_.UpdateMask(should_show); |
| SetShadowBounds(should_show ? base::make_optional(gfx::ToEnclosedRect( |
| transform_window_.GetTransformedBounds())) |
| : base::nullopt); |
| if (transform_window_.IsMinimized()) { |
| caption_container_view_->UpdatePreviewRoundedCorners( |
| should_show, kOverviewWindowRoundingDp); |
| } |
| } |
| |
| void OverviewItem::OnStartingAnimationComplete() { |
| DCHECK(item_widget_.get()); |
| if (transform_window_.IsMinimized()) { |
| // Fade the title in if minimized. The rest of |item_widget_| should already |
| // be shown. |
| caption_container_view_->SetHeaderVisibility( |
| CaptionContainerView::HeaderVisibility::kVisible); |
| } else { |
| FadeInWidgetAndMaybeSlideOnEnter( |
| item_widget_.get(), OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN, |
| /*slide=*/false, /*observe=*/false); |
| } |
| const bool show_backdrop = |
| GetWindowDimensionsType() != |
| ScopedOverviewTransformWindow::GridWindowFillMode::kNormal; |
| caption_container_view_->SetBackdropVisibility(show_backdrop); |
| UpdateCannotSnapWarningVisibility(); |
| } |
| |
| void OverviewItem::SetOpacity(float opacity) { |
| item_widget_->SetOpacity(opacity); |
| transform_window_.SetOpacity(opacity); |
| if (cannot_snap_widget_) |
| cannot_snap_widget_->SetOpacity(opacity); |
| } |
| |
| float OverviewItem::GetOpacity() { |
| return item_widget_->GetNativeWindow()->layer()->GetTargetOpacity(); |
| } |
| |
| OverviewAnimationType OverviewItem::GetExitOverviewAnimationType() { |
| if (overview_session_->enter_exit_overview_type() == |
| OverviewSession::EnterExitOverviewType::kImmediateExit) { |
| return OVERVIEW_ANIMATION_NONE; |
| } |
| |
| return should_animate_when_exiting_ |
| ? OVERVIEW_ANIMATION_LAYOUT_OVERVIEW_ITEMS_ON_EXIT |
| : OVERVIEW_ANIMATION_NONE; |
| } |
| |
| OverviewAnimationType OverviewItem::GetExitTransformAnimationType() { |
| if (overview_session_->enter_exit_overview_type() == |
| OverviewSession::EnterExitOverviewType::kImmediateExit) { |
| return OVERVIEW_ANIMATION_NONE; |
| } |
| |
| return should_animate_when_exiting_ ? OVERVIEW_ANIMATION_RESTORE_WINDOW |
| : OVERVIEW_ANIMATION_RESTORE_WINDOW_ZERO; |
| } |
| |
| void OverviewItem::HandlePressEvent(const gfx::PointF& location_in_screen) { |
| // We allow switching finger while dragging, but do not allow dragging two or |
| // more items. |
| if (overview_session_->window_drag_controller() && |
| overview_session_->window_drag_controller()->item()) { |
| return; |
| } |
| |
| StartDrag(); |
| overview_session_->InitiateDrag(this, location_in_screen); |
| } |
| |
| void OverviewItem::HandleReleaseEvent(const gfx::PointF& location_in_screen) { |
| if (!IsDragItem()) |
| return; |
| |
| overview_grid_->SetSelectionWidgetVisibility(true); |
| overview_session_->CompleteDrag(this, location_in_screen); |
| } |
| |
| void OverviewItem::HandleDragEvent(const gfx::PointF& location_in_screen) { |
| if (!IsDragItem()) |
| return; |
| |
| overview_session_->Drag(this, location_in_screen); |
| } |
| |
| void OverviewItem::HandleLongPressEvent(const gfx::PointF& location_in_screen) { |
| if (!ShouldAllowSplitView()) |
| return; |
| |
| overview_session_->StartSplitViewDragMode(location_in_screen); |
| } |
| |
| void OverviewItem::HandleFlingStartEvent(const gfx::PointF& location_in_screen, |
| float velocity_x, |
| float velocity_y) { |
| overview_session_->Fling(this, location_in_screen, velocity_x, velocity_y); |
| } |
| |
| void OverviewItem::HandleTapEvent() { |
| if (!IsDragItem()) |
| return; |
| |
| overview_session_->ActivateDraggedWindow(); |
| } |
| |
| void OverviewItem::HandleGestureEndEvent() { |
| if (!IsDragItem()) |
| return; |
| |
| overview_session_->ResetDraggedWindowGesture(); |
| } |
| |
| bool OverviewItem::ShouldIgnoreGestureEvents() { |
| return IsSlidingOutOverviewFromShelf(); |
| } |
| |
| void OverviewItem::ButtonPressed(views::Button* sender, |
| const ui::Event& event) { |
| DCHECK_EQ(sender, close_button_); |
| if (IsSlidingOutOverviewFromShelf()) |
| return; |
| |
| base::RecordAction( |
| base::UserMetricsAction("WindowSelector_OverviewCloseButton")); |
| if (Shell::Get() |
| ->tablet_mode_controller() |
| ->IsTabletModeWindowManagerEnabled()) { |
| base::RecordAction( |
| base::UserMetricsAction("Tablet_WindowCloseFromOverviewButton")); |
| } |
| CloseWindow(); |
| } |
| |
| void OverviewItem::OnWindowBoundsChanged(aura::Window* window, |
| const gfx::Rect& old_bounds, |
| const gfx::Rect& new_bounds, |
| ui::PropertyChangeReason reason) { |
| // Do not keep the overview bounds if we're shutting down. |
| if (!Shell::Get()->overview_controller()->InOverviewSession()) |
| return; |
| |
| if (reason == ui::PropertyChangeReason::NOT_FROM_ANIMATION) { |
| if (window == GetWindow()) { |
| caption_container_view_->UpdatePreviewView(); |
| } else { |
| // Transient window is repositioned. The new position within the overview |
| // item needs to be recomputed. |
| SetBounds(target_bounds_, OVERVIEW_ANIMATION_NONE); |
| } |
| } |
| } |
| |
| void OverviewItem::OnWindowDestroying(aura::Window* window) { |
| // Stops observing the window and all of its transient descendents. |
| for (auto* window_iter : wm::WindowTransientDescendantIteratorRange( |
| wm::WindowTransientDescendantIterator(window))) { |
| window_iter->RemoveObserver(this); |
| } |
| if (window != GetWindow()) |
| return; |
| transform_window_.OnWindowDestroyed(); |
| |
| if (is_being_dragged_) { |
| Shell::Get()->overview_controller()->UnpauseOcclusionTracker( |
| kOcclusionPauseDurationForDragMs); |
| } |
| } |
| |
| void OverviewItem::OnWindowTitleChanged(aura::Window* window) { |
| if (window != GetWindow()) |
| return; |
| // TODO(flackr): Maybe add the new title to a vector of titles so that we can |
| // filter any of the titles the window had while in the overview session. |
| caption_container_view_->SetTitle(window->GetTitle()); |
| } |
| |
| void OverviewItem::OnImplicitAnimationsCompleted() { |
| transform_window_.Close(); |
| } |
| |
| views::ImageButton* OverviewItem::GetCloseButtonForTesting() { |
| return static_cast<views::ImageButton*>(close_button_); |
| } |
| |
| float OverviewItem::GetCloseButtonVisibilityForTesting() const { |
| return close_button_->layer()->opacity(); |
| } |
| |
| float OverviewItem::GetTitlebarOpacityForTesting() const { |
| return caption_container_view_->header_view()->layer()->opacity(); |
| } |
| |
| gfx::Rect OverviewItem::GetShadowBoundsForTesting() { |
| if (!shadow_ || !shadow_->layer()->visible()) |
| return gfx::Rect(); |
| |
| return shadow_->content_bounds(); |
| } |
| |
| void OverviewItem::SetItemBounds(const gfx::RectF& target_bounds, |
| OverviewAnimationType animation_type) { |
| aura::Window* window = GetWindow(); |
| DCHECK(root_window_ == window->GetRootWindow()); |
| gfx::RectF screen_rect = gfx::RectF(GetTargetBoundsInScreen()); |
| |
| // Avoid division by zero by ensuring screen bounds is not empty. |
| gfx::SizeF screen_size(screen_rect.size()); |
| screen_size.SetToMax(gfx::SizeF(1.f, 1.f)); |
| screen_rect.set_size(screen_size); |
| |
| const int top_view_inset = transform_window_.GetTopInset(); |
| gfx::RectF overview_item_bounds = |
| transform_window_.ShrinkRectToFitPreservingAspectRatio( |
| screen_rect, target_bounds, top_view_inset, kHeaderHeightDp); |
| // Do not set transform for drop target, set bounds instead. |
| if (overview_grid_->IsDropTargetWindow(window)) { |
| window->SetBoundsInScreen(gfx::ToEnclosedRect(overview_item_bounds), |
| wm::GetWindowState(window)->GetDisplay()); |
| window->SetTransform(gfx::Transform()); |
| return; |
| } |
| |
| gfx::Transform transform = ScopedOverviewTransformWindow::GetTransformForRect( |
| screen_rect, overview_item_bounds); |
| ScopedOverviewTransformWindow::ScopedAnimationSettings animation_settings; |
| transform_window_.BeginScopedAnimation(animation_type, &animation_settings); |
| SetTransform(window, transform); |
| } |
| |
| void OverviewItem::CreateWindowLabel() { |
| views::Widget::InitParams params; |
| params.type = views::Widget::InitParams::TYPE_POPUP; |
| params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
| params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW; |
| params.visible_on_all_workspaces = true; |
| params.layer_type = ui::LAYER_NOT_DRAWN; |
| params.name = "OverviewModeLabel"; |
| params.activatable = |
| views::Widget::InitParams::Activatable::ACTIVATABLE_DEFAULT; |
| params.accept_events = true; |
| params.parent = transform_window_.window()->parent(); |
| |
| item_widget_ = std::make_unique<views::Widget>(); |
| item_widget_->set_focus_on_creation(false); |
| item_widget_->Init(params); |
| aura::Window* widget_window = item_widget_->GetNativeWindow(); |
| widget_window->parent()->StackChildBelow(widget_window, GetWindow()); |
| widget_window->SetProperty(kHideInDeskMiniViewKey, true); |
| |
| shadow_ = std::make_unique<ui::Shadow>(); |
| shadow_->Init(kShadowElevation); |
| item_widget_->GetLayer()->Add(shadow_->layer()); |
| |
| close_button_ = new OverviewCloseButton(this); |
| caption_container_view_ = new CaptionContainerView( |
| this, GetWindow(), transform_window_.IsMinimized(), close_button_); |
| item_widget_->SetContentsView(caption_container_view_); |
| item_widget_->Show(); |
| item_widget_->SetOpacity(0.f); |
| item_widget_->GetLayer()->SetMasksToBounds(false); |
| } |
| |
| void OverviewItem::UpdateHeaderLayout(OverviewAnimationType animation_type) { |
| gfx::RectF transformed_window_bounds = |
| transform_window_.overview_bounds().value_or( |
| transform_window_.GetTransformedBounds()); |
| ::wm::TranslateRectFromScreen(root_window_, &transformed_window_bounds); |
| |
| aura::Window* widget_window = item_widget_->GetNativeWindow(); |
| ScopedOverviewAnimationSettings animation_settings(animation_type, |
| widget_window); |
| // Create a start animation observer if this is an enter overview layout |
| // animation. |
| if (animation_type == OVERVIEW_ANIMATION_LAYOUT_OVERVIEW_ITEMS_ON_ENTER) { |
| auto enter_observer = std::make_unique<EnterAnimationObserver>(); |
| animation_settings.AddObserver(enter_observer.get()); |
| Shell::Get()->overview_controller()->AddEnterAnimationObserver( |
| std::move(enter_observer)); |
| } |
| |
| // |widget_window| is sized to the same bounds as the original window plus |
| // some space for the header and a little padding. |
| gfx::Rect label_rect(0, -kHeaderHeightDp, transformed_window_bounds.width(), |
| kHeaderHeightDp + transformed_window_bounds.height()); |
| label_rect.Inset(-kOverviewMargin, -kOverviewMargin); |
| widget_window->SetBounds(label_rect); |
| |
| gfx::Transform label_transform; |
| label_transform.Translate(gfx::ToRoundedInt(transformed_window_bounds.x()), |
| gfx::ToRoundedInt(transformed_window_bounds.y())); |
| widget_window->SetTransform(label_transform); |
| } |
| |
| void OverviewItem::AnimateOpacity(float opacity, |
| OverviewAnimationType animation_type) { |
| DCHECK_GE(opacity, 0.f); |
| DCHECK_LE(opacity, 1.f); |
| ScopedOverviewTransformWindow::ScopedAnimationSettings animation_settings; |
| transform_window_.BeginScopedAnimation(animation_type, &animation_settings); |
| transform_window_.SetOpacity(opacity); |
| |
| const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity; |
| aura::Window* widget_window = item_widget_->GetNativeWindow(); |
| ScopedOverviewAnimationSettings animation_settings_label(animation_type, |
| widget_window); |
| widget_window->layer()->SetOpacity(header_opacity); |
| |
| if (cannot_snap_widget_) { |
| aura::Window* cannot_snap_widget_window = |
| cannot_snap_widget_->GetNativeWindow(); |
| ScopedOverviewAnimationSettings animation_settings_label( |
| animation_type, cannot_snap_widget_window); |
| cannot_snap_widget_window->layer()->SetOpacity(opacity); |
| } |
| } |
| |
| void OverviewItem::StartDrag() { |
| overview_grid_->SetSelectionWidgetVisibility(false); |
| |
| // |transform_window_| handles hiding shadow and rounded edges mask while |
| // animating, and applies them after animation is complete. Prevent the |
| // shadow and rounded edges mask from showing up after dragging in the case |
| // the window is pressed while still animating. |
| transform_window_.CancelAnimationsListener(); |
| |
| aura::Window* widget_window = item_widget_->GetNativeWindow(); |
| aura::Window* window = GetWindow(); |
| if (widget_window && widget_window->parent() == window->parent()) { |
| // TODO(xdai): This might not work if there is an always on top window. |
| // See crbug.com/733760. |
| widget_window->parent()->StackChildAtTop(window); |
| widget_window->parent()->StackChildBelow(widget_window, window); |
| } |
| } |
| |
| aura::Window::Windows OverviewItem::GetWindowsForHomeGesture() { |
| aura::Window::Windows windows = {item_widget_->GetNativeWindow()}; |
| if (!transform_window_.IsMinimized()) { |
| for (auto* window : wm::GetTransientTreeIterator(GetWindow())) |
| windows.push_back(window); |
| } |
| if (cannot_snap_widget_) |
| windows.push_back(cannot_snap_widget_->GetNativeWindow()); |
| return windows; |
| } |
| |
| } // namespace ash |