blob: e218bd54c48b77333faad230104620184f6990ed [file] [log] [blame]
// Copyright (c) 2012 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 <memory>
#include <string>
#include <utility>
#include <vector>
#include "ash/app_list/views/app_list_drag_and_drop_host.h"
#include "ash/public/cpp/shelf_model_observer.h"
#include "ash/public/interfaces/app_list_view.mojom.h"
#include "ash/public/interfaces/shelf.mojom.h"
#include "ash/shelf/ink_drop_button_listener.h"
#include "ash/shelf/overflow_bubble.h"
#include "ash/shelf/overflow_bubble_view.h"
#include "ash/shelf/shelf_button_pressed_metric_tracker.h"
#include "ash/shelf/shelf_tooltip_manager.h"
#include "ash/shell_observer.h"
#include "ash/system/model/virtual_keyboard_model.h"
#include "ash/wm/tablet_mode/tablet_mode_observer.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/animation/bounds_animator_observer.h"
#include "ui/views/animation/ink_drop_state.h"
#include "ui/views/context_menu_controller.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/menu/menu_types.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/views/view.h"
#include "ui/views/view_model.h"
namespace ui {
class SimpleMenuModel;
namespace views {
class BoundsAnimator;
class MenuRunner;
class Separator;
} // namespace views
namespace ash {
class AppListButton;
class BackButton;
class DragImageView;
class OverflowBubble;
class OverflowButton;
class ScopedRootWindowForNewWindows;
class Shelf;
class ShelfAppButton;
class ShelfButton;
class ShelfModel;
struct ShelfItem;
class ShelfMenuModelAdapter;
class ShelfWidget;
enum ShelfAlignmentUmaEnumValue {
// Must be last entry in enum.
// ShelfView contains the shelf items visible within an active user session.
// ShelfView and LoginShelfView should never be shown together.
// In the following example, there are 12 apps to place on the shelf, plus
// the app list and back buttons, which make 14 shelf items in total.
// If there is enough screen space, all icons can fit:
// -------------------------------------------------------------------------
// | 1 | | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
// -------------------------------------------------------------------------
// ^ ^
// | |
// first_visible_index = 1 (app list) last_visible_index = 12
// (back button = 0 is hidden)
// Where:
// 0 = back button (only shown in tablet mode)
// 1 = app list button
// If screen space is more constrained, some icons are placed in an overflow
// menu (which holds its own instance of ShelfView):
// first_visible_index = 10 last_visible_index = 13
// (for the overflow) (for overflow)
// | |
// v v
// ---------------------
// | 10 | 11 | 12 | 13 |
// ---------------------
// ^
// --------------------------------------------------
// | 1 | | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... |
// --------------------------------------------------
// ^ ^ ^
// | | L-- overflow button
// first_visible_index = 1 |
// (for the main shelf) last_visible_index = 9
// (back button = 0
// is hidden)
class ASH_EXPORT ShelfView : public views::View,
public ShelfModelObserver,
public ShellObserver,
public InkDropButtonListener,
public views::ContextMenuController,
public views::FocusTraversable,
public views::BoundsAnimatorObserver,
public app_list::ApplicationDragAndDropHost,
public ash::TabletModeObserver,
public VirtualKeyboardModel::Observer {
ShelfView(ShelfModel* model, Shelf* shelf, ShelfWidget* shelf_widget);
~ShelfView() override;
Shelf* shelf() const { return shelf_; }
ShelfModel* model() const { return model_; }
void Init();
// Returns the ideal bounds of the specified item, or an empty rect if id
// isn't know. If the item is in an overflow shelf, the overflow icon location
// will be returned.
gfx::Rect GetIdealBoundsOfItemIcon(const ShelfID& id);
// Returns true if we're showing a menu. Note the menu could be either the
// context menu or the application select menu.
bool IsShowingMenu() const;
// Returns true if we're showing a menu for |view|. |view| could be a
// ShelfAppButton or the ShelfView.
bool IsShowingMenuForView(const views::View* view) const;
// Returns true if overflow bubble is shown.
bool IsShowingOverflowBubble() const;
// Sets owner overflow bubble instance from which this shelf view pops
// out as overflow.
void set_owner_overflow_bubble(OverflowBubble* owner) {
owner_overflow_bubble_ = owner;
void set_focused_button(ShelfButton* focused) { focused_button_ = focused; }
AppListButton* GetAppListButton() const;
BackButton* GetBackButton() const;
OverflowButton* GetOverflowButton() const;
// Updates the union of all the shelf item bounds shown by this shelf view.
// This is used to determine the common area where the mouse can hover
// for showing tooltips without stuttering over gaps.
void UpdateVisibleShelfItemBoundsUnion();
// Returns true if the mouse cursor exits the area for launcher tooltip.
// There are thin gaps between launcher buttons but the tooltip shouldn't hide
// in the gaps, but the tooltip should hide if the mouse moved totally outside
// of the buttons area.
bool ShouldHideTooltip(const gfx::Point& cursor_location) const;
// Returns true if a tooltip should be shown for the shelf item |view|.
bool ShouldShowTooltipForView(const views::View* view) const;
// Returns the title of the shelf item |view|.
base::string16 GetTitleForView(const views::View* view) const;
// Returns rectangle bounding all visible launcher items. Used screen
// coordinate system.
gfx::Rect GetVisibleItemsBoundsInScreen();
// Overridden from views::View:
gfx::Size CalculatePreferredSize() const override;
void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
FocusTraversable* GetPaneFocusTraversable() override;
bool OnKeyPressed(const ui::KeyEvent& event) override;
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
View* GetTooltipHandlerForPoint(const gfx::Point& point) override;
// InkDropButtonListener:
void ButtonPressed(views::Button* sender,
const ui::Event& event,
views::InkDrop* ink_drop) override;
// Overridden from FocusTraversable:
views::FocusSearch* GetFocusSearch() override;
FocusTraversable* GetFocusTraversableParent() override;
View* GetFocusTraversableParentView() override;
// Overridden from app_list::ApplicationDragAndDropHost:
void CreateDragIconProxy(const gfx::Point& location_in_screen_coordinates,
const gfx::ImageSkia& icon,
views::View* replaced_view,
const gfx::Vector2d& cursor_offset_from_center,
float scale_factor) override;
// Overridden from ash::TabletModeObserver:
void OnTabletModeStarted() override;
void OnTabletModeEnded() override;
// Overridden from VirtualKeyboardModel::Observer:
void OnVirtualKeyboardVisibilityChanged() override;
void CreateDragIconProxyByLocationWithNoAnimation(
const gfx::Point& origin_in_screen_coordinates,
const gfx::ImageSkia& icon,
views::View* replaced_view,
float scale_factor,
int blur_radius) override;
void UpdateDragIconProxy(
const gfx::Point& location_in_screen_coordinates) override;
void UpdateDragIconProxyByLocation(
const gfx::Point& origin_in_screen_coordinates) override;
void DestroyDragIconProxy() override;
bool StartDrag(const std::string& app_id,
const gfx::Point& location_in_screen_coordinates) override;
bool Drag(const gfx::Point& location_in_screen_coordinates) override;
void EndDrag(bool cancel) override;
// Returns true if |event| on the shelf item is going to activate the item.
// Used to determine whether a pending ink drop should be shown or not.
bool ShouldEventActivateButton(views::View* view, const ui::Event& event);
// Swaps the given button with the next one if |with_next| is true, or with
// the previous one if |with_next| is false.
void SwapButtons(ShelfButton* button_to_swap, bool with_next);
// The shelf buttons use the Pointer interface to enable item reordering.
void PointerPressedOnButton(views::View* view,
Pointer pointer,
const ui::LocatedEvent& event);
void PointerDraggedOnButton(views::View* view,
Pointer pointer,
const ui::LocatedEvent& event);
void PointerReleasedOnButton(views::View* view,
Pointer pointer,
bool canceled);
// Returns whether |item| should belong in the pinned section of the shelf.
bool IsItemPinned(const ShelfItem& item) const;
// Returns the index of the item after which the separator should be shown,
// or -1 if no separator is required.
int GetSeparatorIndex() const;
// Update the layout when entering or exiting tablet mode. Have the owning
// widget call this instead of observing changes ourselves to ensure this
// happens after the tablet related changes in ShelfController.
void OnTabletModeChanged();
// True if the current |drag_view_| is the given |drag_view|.
bool IsDraggedView(const ShelfAppButton* drag_view) const;
// Returns the list of open windows that correspond to the app represented by
// this shelf view.
const std::vector<aura::Window*> GetOpenWindowsForShelfView(
views::View* view);
// The three methods below return the first or last focusable child of the
// set including both the main shelf and the overflow shelf it it's showing.
// - The first focusable child is either the app list button, or the back
// button in tablet mode.
// - The last focusable child can be either 1) the last app icon on the main
// shelf if there aren't enough apps to overflow, 2) the overflow button
// if it's visible but the overflow bubble isn't showing, or 3) the last
// app icon in the overflow bubble if it's showing.
views::View* FindFirstOrLastFocusableChild(bool last);
views::View* FindFirstFocusableChild();
views::View* FindLastFocusableChild();
void OnShelfButtonAboutToRequestFocusFromTabTraversal(ShelfButton* button,
bool reverse);
// Return the view model for test purposes.
const views::ViewModel* view_model_for_test() const {
return view_model_.get();
// Returns the main shelf. This can be called on either the main shelf
// or the overflow shelf.
ShelfView* main_shelf() { return main_shelf_ ? main_shelf_ : this; }
// Returns the overflow shelf. This can be called on either the main shelf
// or the overflow shelf. Returns nullptr if the overflow shelf isn't visible.
ShelfView* overflow_shelf() {
if (is_overflow_mode())
return this;
return IsShowingOverflowBubble()
? overflow_bubble_->bubble_view()->shelf_view()
: nullptr;
const ShelfAppButton* drag_view() const { return drag_view_; }
// Returns true when this ShelfView is used for Overflow Bubble.
// In this mode, it does not show app list and overflow button.
// Note:
// * When Shelf can contain only one item (the overflow button) due to very
// small resolution screen, the overflow bubble can show the app list
// button.
bool is_overflow_mode() const { return overflow_mode_; }
int first_visible_index() const { return first_visible_index_; }
int last_visible_index() const { return last_visible_index_; }
int number_of_visible_apps() const {
if (is_overflow_mode())
return last_visible_index_ - first_visible_index_ + 1;
return last_visible_index_ - 1;
ShelfWidget* shelf_widget() const { return shelf_widget_; }
OverflowBubble* overflow_bubble() { return overflow_bubble_.get(); }
views::ViewModel* view_model() { return view_model_.get(); }
friend class ShelfViewTestAPI;
class FadeOutAnimationDelegate;
class StartFadeAnimationDelegate;
struct AppCenteringStrategy {
bool center_on_screen = false;
bool overflow = false;
enum RemovableState {
REMOVABLE, // Item can be removed when dragged away.
DRAGGABLE, // Item can be dragged, but will snap always back to origin.
NOT_REMOVABLE, // Item is fixed and can never be removed.
// Minimum distance before drag starts.
static const int kMinimumDragDistance;
bool dragging() const { return drag_pointer_ != NONE; }
// Sets the bounds of each view to its ideal bounds.
void LayoutToIdealBounds();
// Update all button's visibility in overflow.
void UpdateAllButtonsVisibilityInOverflowMode();
void LayoutAppListAndBackButtonHighlight() const;
// Returns the size that's actually available for app icons. Size occupied
// by the app list button and back button plus all appropriate margins is
// not available for app icons.
int GetAvailableSpaceForAppIcons() const;
// This method determines which centering strategy is adequate, returns that,
// and sets the |first_visible_index_| and |last_visible_index_| fields
// appropriately.
AppCenteringStrategy CalculateAppCenteringStrategy() const;
// Calculates the ideal bounds. The bounds of each button corresponding to an
// item in the model is set in |view_model_|.
void CalculateIdealBounds() const;
void LayoutOverflowButton() const;
// Returns the index of the last view whose max primary axis coordinate is
// less than |max_value|. Returns -1 if nothing fits, or there are no views.
int IndexOfLastItemThatFitsSize(int max_value) const;
// Animates the bounds of each view to its ideal bounds.
void AnimateToIdealBounds();
// Creates the view used to represent |item|.
views::View* CreateViewForItem(const ShelfItem& item);
// Fades |view| from an opacity of 0 to 1. This is when adding a new item.
void FadeIn(views::View* view);
// Invoked when the pointer has moved enough to trigger a drag. Sets
// internal state in preparation for the drag.
void PrepareForDrag(Pointer pointer, const ui::LocatedEvent& event);
// Invoked when the mouse is dragged. Updates the models as appropriate.
void ContinueDrag(const ui::LocatedEvent& event);
// Scroll the view to show more content in the direction of the user's drag.
void ScrollForUserDrag(int offset);
// Increase the speed of an existing scroll.
void SpeedUpDragScrolling();
// Reorder |drag_view_| according to the latest dragging coordinate.
void MoveDragViewTo(int primary_axis_coordinate);
// Ends the drag on the other shelf. (ie if we are on main shelf, ends drag on
// the overflow shelf). Invoked when a shelf item is being dragged from one
// shelf to the other.
void EndDragOnOtherShelf(bool cancel);
// Handles ripping off an item from the shelf. Returns true when the item got
// removed.
bool HandleRipOffDrag(const ui::LocatedEvent& event);
// Finalize the rip off dragging by either |cancel| the action or validating.
void FinalizeRipOffDrag(bool cancel);
// Check if an item can be ripped off or not.
RemovableState RemovableByRipOff(int index) const;
// Returns true if |typea| and |typeb| should be in the same drag range.
bool SameDragType(ShelfItemType typea, ShelfItemType typeb) const;
// Returns the range (in the model) the item at the specified index can be
// dragged to.
std::pair<int, int> GetDragRange(int index);
// If there is a drag operation in progress it's canceled. If |modified_index|
// is valid, the new position of the corresponding item is returned.
int CancelDrag(int modified_index);
// Returns rectangle bounds used for drag insertion.
// Note:
// * When overflow button is visible, returns bounds from first item
// to overflow button.
// * In the overflow mode, returns only bubble's bounds.
gfx::Rect GetBoundsForDragInsertInScreen();
// Common setup done for all children.
void ConfigureChildView(views::View* view);
// Toggles the overflow menu.
void ToggleOverflowBubble();
// Invoked after the fading out animation for item deletion is ended.
void OnFadeOutAnimationEnded();
// Fade in last visible item.
void StartFadeInLastVisibleItem();
// Updates the visible range of overflow items in |overflow_view|.
void UpdateOverflowRange(ShelfView* overflow_view) const;
// Gets the menu anchor rect for menus. |source| is the view that is
// asking for a menu, |location| is the location of the event, |context_menu|
// is whether the menu is for a context or application menu.
gfx::Rect GetMenuAnchorRect(const views::View& source,
const gfx::Point& location,
bool context_menu) const;
void AnnounceShelfAlignment();
void AnnounceShelfAutohideBehavior();
// Overridden from ui::EventHandler:
void OnGestureEvent(ui::GestureEvent* event) override;
bool OnMouseWheel(const ui::MouseWheelEvent& event) override;
// Overridden from ShelfModelObserver:
void ShelfItemAdded(int model_index) override;
void ShelfItemRemoved(int model_index, const ShelfItem& old_item) override;
void ShelfItemChanged(int model_index, const ShelfItem& old_item) override;
void ShelfItemMoved(int start_index, int target_index) override;
void ShelfItemDelegateChanged(const ShelfID& id,
ShelfItemDelegate* old_delegate,
ShelfItemDelegate* delegate) override;
void ShelfItemStatusChanged(const ShelfID& id) override;
// Overridden from ShellObserver:
void OnShelfAlignmentChanged(aura::Window* root_window) override;
void OnShelfAutoHideBehaviorChanged(aura::Window* root_window) override;
// Handles the result when querying ShelfItemDelegates for context menu items.
// Shows a default shelf context menu with optional extra custom |menu_items|.
void AfterGetContextMenuItems(const ShelfID& shelf_id,
const gfx::Point& point,
views::View* source,
ui::MenuSourceType source_type,
std::vector<mojom::MenuItemPtr> menu_items);
// Handles the result of an item selection, records the |action| taken and
// optionally shows an application menu with the given |menu_items|.
void AfterItemSelected(
const ShelfItem& item,
views::Button* sender,
std::unique_ptr<ui::Event> event,
views::InkDrop* ink_drop,
ShelfAction action,
base::Optional<std::vector<mojom::MenuItemPtr>> menu_items);
// Overridden from views::ContextMenuController:
void ShowContextMenuForViewImpl(views::View* source,
const gfx::Point& point,
ui::MenuSourceType source_type) override;
// Show either a context or normal click menu of given |menu_model|.
// If |context_menu| is set, the displayed menu is a context menu and not
// a menu listing one or more running applications.
// The |click_point| is only used for |context_menu|'s.
void ShowMenu(std::unique_ptr<ui::SimpleMenuModel> menu_model,
views::View* source,
const gfx::Point& click_point,
bool context_menu,
ui::MenuSourceType source_type);
// Callback for MenuRunner.
void OnMenuClosed(views::View* source);
// Overridden from views::BoundsAnimatorObserver:
void OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) override;
void OnBoundsAnimatorDone(views::BoundsAnimator* animator) override;
// Returns true if the (press down) |event| is a repost event from an event
// which just closed the menu of a shelf item. If it occurs on the same shelf
// item, we should ignore the call.
bool IsRepostEvent(const ui::Event& event);
// Returns true if the given |item| is supposed to be shown to the user.
bool ShouldShowShelfItem(const ShelfItem& item);
// Convenience accessor to model_->items().
const ShelfItem* ShelfItemForView(const views::View* view) const;
// Get the distance from the given |coordinate| to the closest point on this
// launcher/shelf.
int CalculateShelfDistance(const gfx::Point& coordinate) const;
bool CanPrepareForDrag(Pointer pointer, const ui::LocatedEvent& event);
// Updates the back button opacity and focus behavior based on tablet mode.
void UpdateBackButton();
// Set background blur to the dragged image. |size| is the image size.
void SetDragImageBlur(const gfx::Size& size, int blur_radius);
// The model; owned by Launcher.
ShelfModel* model_;
// The shelf controller; owned by RootWindowController.
Shelf* shelf_;
// The shelf widget for this view. For overflow bubbles, this is the widget
// for the shelf, not for the bubble.
ShelfWidget* shelf_widget_;
// Used to manage the set of active launcher buttons. There is a view per
// item in |model_|.
std::unique_ptr<views::ViewModel> view_model_;
// Index of the first visible launcher item. This is either:
// * 0 (back button) for the main shelf when tablet mode is on
// * 1 (app list button) for the main shelf when tablet mode is off
// * > 1 when this shelf view is the overflow shelf view and only shows a
// subset of items.
mutable int first_visible_index_ = 0;
// Last index of a launcher button that is visible (does not go into
// overflow).
mutable int last_visible_index_ = -1;
std::unique_ptr<views::BoundsAnimator> bounds_animator_;
OverflowButton* overflow_button_ = nullptr;
std::unique_ptr<OverflowBubble> overflow_bubble_;
OverflowBubble* owner_overflow_bubble_ = nullptr;
ShelfTooltipManager tooltip_;
// Pointer device that initiated the current drag operation. If there is no
// current dragging operation, this is NONE.
Pointer drag_pointer_ = NONE;
// The view being dragged. This is set immediately when the mouse is pressed.
// |dragging_| is set only if the mouse is dragged far enough.
ShelfAppButton* drag_view_ = nullptr;
// The view showing a context menu. This can be either a ShelfView or
// ShelfAppButton.
views::View* menu_owner_ = nullptr;
// Position of the mouse down event in |drag_view_|'s coordinates.
gfx::Point drag_origin_;
// Index |drag_view_| was initially at.
int start_drag_index_ = -1;
// Used for the context menu of a particular item.
ShelfID context_menu_id_;
std::unique_ptr<views::FocusSearch> focus_search_;
// Responsible for building and running all menus.
std::unique_ptr<ShelfMenuModelAdapter> shelf_menu_model_adapter_;
// True when an item being inserted or removed in the model cancels a drag.
bool cancelling_drag_model_changed_ = false;
// The item with an in-flight async request for a context menu or selection
// (which shows a shelf item application menu if multiple windows are open).
// Used to avoid multiple concurrent menu requests. The value is null if none.
ShelfID item_awaiting_response_;
// The timestamp of the event which closed the last menu - or 0.
base::TimeTicks closing_event_time_;
// The button that is currently focused for keyboard navigation, or null
// if nothing is focused.
ShelfButton* focused_button_ = nullptr;
// True if a drag and drop operation created/pinned the item in the launcher
// and it needs to be deleted/unpinned again if the operation gets cancelled.
bool drag_and_drop_item_pinned_ = false;
// The ShelfItem currently used for drag and drop; empty if none.
ShelfID drag_and_drop_shelf_id_;
// The original launcher item's size before the dragging operation.
gfx::Size pre_drag_and_drop_size_;
// The image proxy for drag operations when a drag and drop host exists and
// the item can be dragged outside the app grid.
std::unique_ptr<ash::DragImageView> drag_image_;
// The owner of a mask layer used to clip the background blur.
std::unique_ptr<ui::LayerOwner> drag_image_mask_;
// The cursor offset to the middle of the dragged item.
gfx::Vector2d drag_image_offset_;
// The view which gets replaced by our drag icon proxy.
views::View* drag_replaced_view_ = nullptr;
// True when the icon was dragged off the shelf.
bool dragged_off_shelf_ = false;
// True when an item is dragged from one shelf to another (eg. overflow).
bool dragged_to_another_shelf_ = false;
// The rip off view when a snap back operation is underway.
views::View* snap_back_from_rip_off_view_ = nullptr;
// True when this ShelfView is used for Overflow Bubble.
bool overflow_mode_ = false;
// Holds a pointer to main ShelfView when a ShelfView is in overflow mode.
ShelfView* main_shelf_ = nullptr;
// True when ripped item from overflow bubble is entered into Shelf.
bool dragged_off_from_overflow_to_shelf_ = false;
// True if the event is a repost event from a event which has just closed the
// menu of the same shelf item.
bool is_repost_event_on_same_item_ = false;
// Record the index for the last pressed shelf item. This variable is used to
// check if a repost event occurs on the same shelf item as previous one. If
// so, the repost event should be ignored.
int last_pressed_index_ = -1;
// Tracks UMA metrics based on shelf button press actions.
ShelfButtonPressedMetricTracker shelf_button_pressed_metric_tracker_;
// A reference to the view used as a separator between pinned and unpinned
// items.
views::Separator* separator_ = nullptr;
// The union of all visible shelf item bounds. Used for showing tooltips in
// a continuous manner.
gfx::Rect visible_shelf_item_bounds_union_;
// A view to draw a background behind the app list and back buttons.
// Owned by the view hierarchy.
views::View* back_and_app_list_background_ = nullptr;
// A view used to make accessibility announcements (changes in the shelf's
// alignment or auto-hide state).
views::View* announcement_view_ = nullptr; // Owned by ShelfView
// For dragging: -1 if scrolling back, 1 if scrolling forward, 0 if neither.
int drag_scroll_dir_ = 0;
// Used to periodically call ScrollForUserDrag.
base::RepeatingTimer scrolling_timer_;
// Used to call SpeedUpDragScrolling.
base::OneShotTimer speed_up_drag_scrolling_;
// The AppListViewState recorded before a button press, used to record app
// launching metrics. This allows an accurate AppListViewState to be recorded
// before AppListViewState changes.
ash::mojom::AppListViewState recorded_app_list_view_state_;
// Whether home launcher was shown before a button press, used to record app
// launching metrics. This is recorded in case home_launcher_shown_ is changed
// before the metric is recorded.
bool recorded_home_launcher_shown_ = false;
base::WeakPtrFactory<ShelfView> weak_factory_;
} // namespace ash