blob: ea92f29cff4e9941a00e02dfee7f63e253f23ae9 [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 "ash/shelf/shelf_view.h"
#include <algorithm>
#include <memory>
#include "ash/ash_constants.h"
#include "ash/drag_drop/drag_image_view.h"
#include "ash/metrics/user_metrics_recorder.h"
#include "ash/public/cpp/shelf_item_delegate.h"
#include "ash/public/cpp/shelf_model.h"
#include "ash/scoped_root_window_for_new_windows.h"
#include "ash/screen_util.h"
#include "ash/shelf/app_list_button.h"
#include "ash/shelf/overflow_bubble.h"
#include "ash/shelf/overflow_bubble_view.h"
#include "ash/shelf/overflow_button.h"
#include "ash/shelf/shelf.h"
#include "ash/shelf/shelf_application_menu_model.h"
#include "ash/shelf/shelf_button.h"
#include "ash/shelf/shelf_constants.h"
#include "ash/shelf/shelf_context_menu_model.h"
#include "ash/shelf/shelf_controller.h"
#include "ash/shelf/shelf_widget.h"
#include "ash/shell.h"
#include "ash/shell_delegate.h"
#include "ash/shell_port.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/wm/root_window_finder.h"
#include "ash/wm/tablet_mode/tablet_mode_controller.h"
#include "base/auto_reset.h"
#include "base/metrics/histogram_macros.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/app_list/app_list_features.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/models/simple_menu_model.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animator.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/events/event_utils.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point.h"
#include "ui/views/animation/bounds_animator.h"
#include "ui/views/border.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/menu/menu_model_adapter.h"
#include "ui/views/controls/menu/menu_runner.h"
#include "ui/views/focus/focus_search.h"
#include "ui/views/view_model.h"
#include "ui/views/view_model_utils.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/core/coordinate_conversion.h"
using gfx::Animation;
using views::View;
namespace ash {
// The proportion of the shelf space reserved for non-panel icons. Panels
// may flow into this space but will be put into the overflow bubble if there
// is contention for the space.
const float kReservedNonPanelIconProportion = 0.67f;
// The distance of the cursor from the outer rim of the shelf before it
// separates.
const int kRipOffDistance = 48;
// The rip off drag and drop proxy image should get scaled by this factor.
const float kDragAndDropProxyScale = 1.2f;
// The opacity represents that this partially disappeared item will get removed.
const float kDraggedImageOpacity = 0.5f;
namespace {
// A class to temporarily disable a given bounds animator.
class BoundsAnimatorDisabler {
public:
explicit BoundsAnimatorDisabler(views::BoundsAnimator* bounds_animator)
: old_duration_(bounds_animator->GetAnimationDuration()),
bounds_animator_(bounds_animator) {
bounds_animator_->SetAnimationDuration(1);
}
~BoundsAnimatorDisabler() {
bounds_animator_->SetAnimationDuration(old_duration_);
}
private:
// The previous animation duration.
int old_duration_;
// The bounds animator which gets used.
views::BoundsAnimator* bounds_animator_;
DISALLOW_COPY_AND_ASSIGN(BoundsAnimatorDisabler);
};
// Custom FocusSearch used to navigate the shelf in the order items are in
// the ViewModel.
class ShelfFocusSearch : public views::FocusSearch {
public:
explicit ShelfFocusSearch(views::ViewModel* view_model)
: FocusSearch(nullptr, true, true), view_model_(view_model) {}
~ShelfFocusSearch() override = default;
// views::FocusSearch overrides:
View* FindNextFocusableView(View* starting_view,
bool reverse,
Direction direction,
bool check_starting_view,
views::FocusTraversable** focus_traversable,
View** focus_traversable_view) override {
int index = view_model_->GetIndexOfView(starting_view);
if (index == -1)
return view_model_->view_at(0);
if (reverse) {
--index;
if (index < 0)
index = view_model_->view_size() - 1;
} else {
++index;
if (index >= view_model_->view_size())
index = 0;
}
return view_model_->view_at(index);
}
private:
views::ViewModel* view_model_;
DISALLOW_COPY_AND_ASSIGN(ShelfFocusSearch);
};
// AnimationDelegate used when inserting a new item. This steadily increases the
// opacity of the layer as the animation progress.
class FadeInAnimationDelegate : public gfx::AnimationDelegate {
public:
explicit FadeInAnimationDelegate(views::View* view) : view_(view) {}
~FadeInAnimationDelegate() override = default;
// AnimationDelegate overrides:
void AnimationProgressed(const Animation* animation) override {
view_->layer()->SetOpacity(animation->GetCurrentValue());
view_->layer()->ScheduleDraw();
}
void AnimationEnded(const Animation* animation) override {
view_->layer()->SetOpacity(1.0f);
view_->layer()->ScheduleDraw();
}
void AnimationCanceled(const Animation* animation) override {
view_->layer()->SetOpacity(1.0f);
view_->layer()->ScheduleDraw();
}
private:
views::View* view_;
DISALLOW_COPY_AND_ASSIGN(FadeInAnimationDelegate);
};
void ReflectItemStatus(const ShelfItem& item, ShelfButton* button) {
switch (item.status) {
case STATUS_CLOSED:
button->ClearState(ShelfButton::STATE_RUNNING);
button->ClearState(ShelfButton::STATE_ATTENTION);
break;
case STATUS_RUNNING:
button->AddState(ShelfButton::STATE_RUNNING);
button->ClearState(ShelfButton::STATE_ATTENTION);
break;
case STATUS_ATTENTION:
button->ClearState(ShelfButton::STATE_RUNNING);
button->AddState(ShelfButton::STATE_ATTENTION);
break;
}
}
// Returns the id of the display on which |view| is shown.
int64_t GetDisplayIdForView(View* view) {
aura::Window* window = view->GetWidget()->GetNativeWindow();
return display::Screen::GetScreen()->GetDisplayNearestWindow(window).id();
}
} // namespace
// AnimationDelegate used when deleting an item. This steadily decreased the
// opacity of the layer as the animation progress.
class ShelfView::FadeOutAnimationDelegate : public gfx::AnimationDelegate {
public:
FadeOutAnimationDelegate(ShelfView* host, views::View* view)
: shelf_view_(host), view_(view) {}
~FadeOutAnimationDelegate() override = default;
// AnimationDelegate overrides:
void AnimationProgressed(const Animation* animation) override {
view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
view_->layer()->ScheduleDraw();
}
void AnimationEnded(const Animation* animation) override {
shelf_view_->OnFadeOutAnimationEnded();
}
void AnimationCanceled(const Animation* animation) override {}
private:
ShelfView* shelf_view_;
std::unique_ptr<views::View> view_;
DISALLOW_COPY_AND_ASSIGN(FadeOutAnimationDelegate);
};
// AnimationDelegate used to trigger fading an element in. When an item is
// inserted this delegate is attached to the animation that expands the size of
// the item. When done it kicks off another animation to fade the item in.
class ShelfView::StartFadeAnimationDelegate : public gfx::AnimationDelegate {
public:
StartFadeAnimationDelegate(ShelfView* host, views::View* view)
: shelf_view_(host), view_(view) {}
~StartFadeAnimationDelegate() override = default;
// AnimationDelegate overrides:
void AnimationEnded(const Animation* animation) override {
shelf_view_->FadeIn(view_);
}
void AnimationCanceled(const Animation* animation) override {
view_->layer()->SetOpacity(1.0f);
}
private:
ShelfView* shelf_view_;
views::View* view_;
DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
};
// static
const int ShelfView::kMinimumDragDistance = 8;
ShelfView::ShelfView(ShelfModel* model, Shelf* shelf, ShelfWidget* shelf_widget)
: model_(model),
shelf_(shelf),
shelf_widget_(shelf_widget),
view_model_(new views::ViewModel),
tooltip_(this),
weak_factory_(this) {
DCHECK(model_);
DCHECK(shelf_);
DCHECK(shelf_widget_);
bounds_animator_.reset(new views::BoundsAnimator(this));
bounds_animator_->AddObserver(this);
set_context_menu_controller(this);
focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
}
ShelfView::~ShelfView() {
bounds_animator_->RemoveObserver(this);
model_->RemoveObserver(this);
}
void ShelfView::Init() {
model_->AddObserver(this);
const ShelfItems& items(model_->items());
for (ShelfItems::const_iterator i = items.begin(); i != items.end(); ++i) {
views::View* child = CreateViewForItem(*i);
child->SetPaintToLayer();
view_model_->Add(child, static_cast<int>(i - items.begin()));
AddChildView(child);
}
overflow_button_ = new OverflowButton(this, shelf_);
overflow_button_->set_context_menu_controller(this);
ConfigureChildView(overflow_button_);
AddChildView(overflow_button_);
// We'll layout when our bounds change.
}
void ShelfView::OnShelfAlignmentChanged() {
overflow_button_->OnShelfAlignmentChanged();
LayoutToIdealBounds();
for (int i = 0; i < view_model_->view_size(); ++i) {
if (i >= first_visible_index_ && i <= last_visible_index_)
view_model_->view_at(i)->Layout();
}
tooltip_.Close();
if (overflow_bubble_)
overflow_bubble_->Hide();
// For crbug.com/587931, because AppListButton layout logic is in OnPaint.
AppListButton* app_list_button = GetAppListButton();
if (app_list_button)
app_list_button->SchedulePaint();
}
gfx::Rect ShelfView::GetIdealBoundsOfItemIcon(const ShelfID& id) {
int index = model_->ItemIndexByID(id);
if (index < 0 || last_visible_index_ < 0)
return gfx::Rect();
// Map all items from overflow area to the overflow button. Note that the
// section between last_index_hidden_ and model_->FirstPanelIndex() is the
// list of invisible panel items. However, these items are currently nowhere
// represented and get dropped instead - see (crbug.com/378907). As such there
// is no way to address them or place them. We therefore move them over the
// overflow button.
if (index > last_visible_index_ && index < model_->FirstPanelIndex())
index = last_visible_index_ + 1;
const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
views::View* view = view_model_->view_at(index);
CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
ShelfButton* button = static_cast<ShelfButton*>(view);
gfx::Rect icon_bounds = button->GetIconBounds();
return gfx::Rect(GetMirroredXWithWidthInView(
ideal_bounds.x() + icon_bounds.x(), icon_bounds.width()),
ideal_bounds.y() + icon_bounds.y(), icon_bounds.width(),
icon_bounds.height());
}
void ShelfView::UpdatePanelIconPosition(const ShelfID& id,
const gfx::Point& midpoint) {
int current_index = model_->ItemIndexByID(id);
int first_panel_index = model_->FirstPanelIndex();
if (current_index < first_panel_index)
return;
gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()), midpoint.y());
int target_index = current_index;
while (target_index > first_panel_index &&
shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
view_model_->ideal_bounds(target_index).y()) >
shelf_->PrimaryAxisValue(midpoint_in_view.x(),
midpoint_in_view.y())) {
--target_index;
}
while (target_index < view_model_->view_size() - 1 &&
shelf_->PrimaryAxisValue(
view_model_->ideal_bounds(target_index).right(),
view_model_->ideal_bounds(target_index).bottom()) <
shelf_->PrimaryAxisValue(midpoint_in_view.x(),
midpoint_in_view.y())) {
++target_index;
}
if (current_index != target_index)
model_->Move(current_index, target_index);
}
bool ShelfView::IsShowingMenu() const {
return launcher_menu_runner_.get() && launcher_menu_runner_->IsRunning();
}
bool ShelfView::IsShowingOverflowBubble() const {
return overflow_bubble_.get() && overflow_bubble_->IsShowing();
}
AppListButton* ShelfView::GetAppListButton() const {
for (int i = 0; i < model_->item_count(); ++i) {
if (model_->items()[i].type == TYPE_APP_LIST) {
views::View* view = view_model_->view_at(i);
CHECK_EQ(AppListButton::kViewClassName, view->GetClassName());
return static_cast<AppListButton*>(view);
}
}
NOTREACHED() << "Applist button not found";
return nullptr;
}
bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) const {
gfx::Rect tooltip_bounds;
for (int i = 0; i < child_count(); ++i) {
const views::View* child = child_at(i);
if (child != overflow_button_ && ShouldShowTooltipForView(child))
tooltip_bounds.Union(child->GetMirroredBounds());
}
return !tooltip_bounds.Contains(cursor_location);
}
bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
// TODO(msw): Push this app list state into ShelfItem::shows_tooltip.
if (view == GetAppListButton() && GetAppListButton()->is_showing_app_list())
return false;
const ShelfItem* item = ShelfItemForView(view);
return item && item->shows_tooltip;
}
base::string16 ShelfView::GetTitleForView(const views::View* view) const {
const ShelfItem* item = ShelfItemForView(view);
return item ? item->title : base::string16();
}
gfx::Rect ShelfView::GetVisibleItemsBoundsInScreen() {
gfx::Size preferred_size = GetPreferredSize();
gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
ConvertPointToScreen(this, &origin);
return gfx::Rect(origin, preferred_size);
}
void ShelfView::ButtonPressed(views::Button* sender,
const ui::Event& event,
views::InkDrop* ink_drop) {
if (sender == overflow_button_) {
ToggleOverflowBubble();
shelf_button_pressed_metric_tracker_.ButtonPressed(event, sender,
SHELF_ACTION_NONE);
return;
}
// None of the checks in ShouldEventActivateButton() affects overflow button.
// So, it is safe to be checked after handling overflow button.
if (!ShouldEventActivateButton(sender, event))
return;
// Close the overflow bubble if an item on either shelf is clicked. Press
// events elsewhere will close the overflow shelf via OverflowBubble's
// PointerWatcher functionality.
ShelfView* shelf_view = main_shelf_ ? main_shelf_ : this;
if (shelf_view->IsShowingOverflowBubble())
shelf_view->ToggleOverflowBubble();
// Record the index for the last pressed shelf item.
last_pressed_index_ = view_model_->GetIndexOfView(sender);
DCHECK_LT(-1, last_pressed_index_);
// Place new windows on the same display as the button.
aura::Window* window = sender->GetWidget()->GetNativeWindow();
scoped_root_window_for_new_windows_.reset(
new ScopedRootWindowForNewWindows(window->GetRootWindow()));
// Slow down activation animations if shift key is pressed.
std::unique_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
if (event.IsShiftDown()) {
slowing_animations.reset(new ui::ScopedAnimationDurationScaleMode(
ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
}
// Collect usage statistics before we decide what to do with the click.
switch (model_->items()[last_pressed_index_].type) {
case TYPE_PINNED_APP:
case TYPE_BROWSER_SHORTCUT:
case TYPE_APP:
Shell::Get()->metrics()->RecordUserMetricsAction(
UMA_LAUNCHER_CLICK_ON_APP);
break;
case TYPE_APP_LIST:
Shell::Get()->metrics()->RecordUserMetricsAction(
UMA_LAUNCHER_CLICK_ON_APPLIST_BUTTON);
break;
case TYPE_APP_PANEL:
case TYPE_DIALOG:
break;
case TYPE_UNDEFINED:
NOTREACHED() << "ShelfItemType must be set.";
break;
}
// Run AfterItemSelected directly if the item has no delegate (ie. in tests).
const ShelfItem& item = model_->items()[last_pressed_index_];
if (!model_->GetShelfItemDelegate(item.id)) {
AfterItemSelected(item, sender, ui::Event::Clone(event), ink_drop,
SHELF_ACTION_NONE, base::nullopt);
return;
}
// Notify the item of its selection; handle the result in AfterItemSelected.
model_->GetShelfItemDelegate(item.id)->ItemSelected(
ui::Event::Clone(event), GetDisplayIdForView(this), LAUNCH_FROM_UNKNOWN,
base::Bind(&ShelfView::AfterItemSelected, weak_factory_.GetWeakPtr(),
item, sender, base::Passed(ui::Event::Clone(event)),
ink_drop));
}
////////////////////////////////////////////////////////////////////////////////
// ShelfView, FocusTraversable implementation:
views::FocusSearch* ShelfView::GetFocusSearch() {
return focus_search_.get();
}
views::FocusTraversable* ShelfView::GetFocusTraversableParent() {
return parent()->GetFocusTraversable();
}
View* ShelfView::GetFocusTraversableParentView() {
return this;
}
void ShelfView::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) {
drag_replaced_view_ = replaced_view;
aura::Window* root_window =
drag_replaced_view_->GetWidget()->GetNativeWindow()->GetRootWindow();
drag_image_ = std::make_unique<DragImageView>(
root_window, ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
drag_image_->SetImage(icon);
gfx::Size size = drag_image_->GetPreferredSize();
size.set_width(size.width() * scale_factor);
size.set_height(size.height() * scale_factor);
drag_image_offset_ = gfx::Vector2d(size.width() / 2, size.height() / 2) +
cursor_offset_from_center;
gfx::Rect drag_image_bounds(
location_in_screen_coordinates - drag_image_offset_, size);
drag_image_->SetBoundsInScreen(drag_image_bounds);
drag_image_->SetWidgetVisible(true);
}
void ShelfView::CreateDragIconProxyByLocationWithNoAnimation(
const gfx::Point& origin_in_screen_coordinates,
const gfx::ImageSkia& icon,
views::View* replaced_view,
float scale_factor) {
drag_replaced_view_ = replaced_view;
aura::Window* root_window =
drag_replaced_view_->GetWidget()->GetNativeWindow()->GetRootWindow();
drag_image_ = std::make_unique<DragImageView>(
root_window, ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
drag_image_->SetImage(icon);
gfx::Size size = drag_image_->GetPreferredSize();
size.set_width(size.width() * scale_factor);
size.set_height(size.height() * scale_factor);
gfx::Rect drag_image_bounds(origin_in_screen_coordinates, size);
drag_image_->SetBoundsInScreen(drag_image_bounds);
// Turn off the default visibility animation.
drag_image_->GetWidget()->SetVisibilityAnimationTransition(
views::Widget::ANIMATE_NONE);
drag_image_->SetWidgetVisible(true);
}
void ShelfView::UpdateDragIconProxy(
const gfx::Point& location_in_screen_coordinates) {
// TODO(jennyz): Investigate why drag_image_ becomes null at this point per
// crbug.com/34722, while the app list item is still being dragged around.
if (drag_image_) {
drag_image_->SetScreenPosition(location_in_screen_coordinates -
drag_image_offset_);
}
}
void ShelfView::UpdateDragIconProxyByLocation(
const gfx::Point& origin_in_screen_coordinates) {
if (drag_image_)
drag_image_->SetScreenPosition(origin_in_screen_coordinates);
}
bool ShelfView::IsDraggedView(const ShelfButton* view) const {
return drag_view_ == view;
}
void ShelfView::DestroyDragIconProxy() {
drag_image_.reset();
drag_image_offset_ = gfx::Vector2d(0, 0);
}
bool ShelfView::StartDrag(const std::string& app_id,
const gfx::Point& location_in_screen_coordinates) {
// Bail if an operation is already going on - or the cursor is not inside.
// This could happen if mouse / touch operations overlap.
if (!drag_and_drop_shelf_id_.IsNull() || app_id.empty() ||
!GetBoundsInScreen().Contains(location_in_screen_coordinates))
return false;
// If the AppsGridView (which was dispatching this event) was opened by our
// button, ShelfView dragging operations are locked and we have to unlock.
CancelDrag(-1);
drag_and_drop_item_pinned_ = false;
drag_and_drop_shelf_id_ = ShelfID(app_id);
// Check if the application is pinned - if not, we have to pin it so
// that we can re-arrange the shelf order accordingly. Note that items have
// to be pinned to give them the same (order) possibilities as a shortcut.
// When an item is dragged from overflow to shelf, IsShowingOverflowBubble()
// returns true. At this time, we don't need to pin the item.
if (!IsShowingOverflowBubble() && !model_->IsAppPinned(app_id)) {
model_->PinAppWithID(app_id);
drag_and_drop_item_pinned_ = true;
}
views::View* drag_and_drop_view =
view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
DCHECK(drag_and_drop_view);
// Since there is already an icon presented by the caller, we hide this item
// for now. That has to be done by reducing the size since the visibility will
// change once a regrouping animation is performed.
pre_drag_and_drop_size_ = drag_and_drop_view->size();
drag_and_drop_view->SetSize(gfx::Size());
// First we have to center the mouse cursor over the item.
gfx::Point pt = drag_and_drop_view->GetBoundsInScreen().CenterPoint();
views::View::ConvertPointFromScreen(drag_and_drop_view, &pt);
gfx::Point point_in_root = location_in_screen_coordinates;
::wm::ConvertPointFromScreen(
wm::GetRootWindowAt(location_in_screen_coordinates), &point_in_root);
ui::MouseEvent event(ui::ET_MOUSE_PRESSED, pt, point_in_root,
ui::EventTimeForNow(), 0, 0);
PointerPressedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
// Drag the item where it really belongs.
Drag(location_in_screen_coordinates);
return true;
}
bool ShelfView::Drag(const gfx::Point& location_in_screen_coordinates) {
if (drag_and_drop_shelf_id_.IsNull() ||
!GetBoundsInScreen().Contains(location_in_screen_coordinates))
return false;
gfx::Point pt = location_in_screen_coordinates;
views::View* drag_and_drop_view =
view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
ConvertPointFromScreen(drag_and_drop_view, &pt);
gfx::Point point_in_root = location_in_screen_coordinates;
::wm::ConvertPointFromScreen(
wm::GetRootWindowAt(location_in_screen_coordinates), &point_in_root);
ui::MouseEvent event(ui::ET_MOUSE_DRAGGED, pt, point_in_root,
ui::EventTimeForNow(), 0, 0);
PointerDraggedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
return true;
}
void ShelfView::EndDrag(bool cancel) {
if (drag_and_drop_shelf_id_.IsNull())
return;
views::View* drag_and_drop_view =
view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
PointerReleasedOnButton(drag_and_drop_view, DRAG_AND_DROP, cancel);
// Either destroy the temporarily created item - or - make the item visible.
if (drag_and_drop_item_pinned_ && cancel) {
model_->UnpinAppWithID(drag_and_drop_shelf_id_.app_id);
} else if (drag_and_drop_view) {
if (cancel) {
// When a hosted drag gets canceled, the item can remain in the same slot
// and it might have moved within the bounds. In that case the item need
// to animate back to its correct location.
AnimateToIdealBounds();
} else {
drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
}
}
drag_and_drop_shelf_id_ = ShelfID();
}
bool ShelfView::ShouldEventActivateButton(View* view, const ui::Event& event) {
if (dragging())
return false;
// Ignore if we are already in a pointer event sequence started with a repost
// event on the same shelf item. See crbug.com/343005 for more detail.
if (is_repost_event_on_same_item_)
return false;
// Don't activate the item twice on double-click. Otherwise the window starts
// animating open due to the first click, then immediately minimizes due to
// the second click. The user most likely intended to open or minimize the
// item once, not do both.
if (event.flags() & ui::EF_IS_DOUBLE_CLICK)
return false;
// Ignore if this is a repost event on the last pressed shelf item.
int index = view_model_->GetIndexOfView(view);
if (index == -1)
return false;
return !IsRepostEvent(event) || last_pressed_index_ != index;
}
void ShelfView::PointerPressedOnButton(views::View* view,
Pointer pointer,
const ui::LocatedEvent& event) {
if (drag_view_)
return;
if (IsShowingMenu())
launcher_menu_runner_->Cancel();
int index = view_model_->GetIndexOfView(view);
if (index == -1 || view_model_->view_size() <= 1)
return; // View is being deleted, ignore request.
if (view == GetAppListButton())
return; // View is not draggable, ignore request.
// Only when the repost event occurs on the same shelf item, we should ignore
// the call in ShelfView::ButtonPressed(...).
is_repost_event_on_same_item_ =
IsRepostEvent(event) && (last_pressed_index_ == index);
CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
drag_view_ = static_cast<ShelfButton*>(view);
drag_origin_ = gfx::Point(event.x(), event.y());
UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
static_cast<ShelfAlignmentUmaEnumValue>(
shelf_->SelectValueForShelfAlignment(
SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT)),
SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
}
void ShelfView::PointerDraggedOnButton(views::View* view,
Pointer pointer,
const ui::LocatedEvent& event) {
if (CanPrepareForDrag(pointer, event))
PrepareForDrag(pointer, event);
if (drag_pointer_ == pointer)
ContinueDrag(event);
}
void ShelfView::PointerReleasedOnButton(views::View* view,
Pointer pointer,
bool canceled) {
is_repost_event_on_same_item_ = false;
if (canceled) {
CancelDrag(-1);
} else if (drag_pointer_ == pointer) {
FinalizeRipOffDrag(false);
drag_pointer_ = NONE;
AnimateToIdealBounds();
}
// If the drag pointer is NONE, no drag operation is going on and the
// drag_view can be released.
if (drag_pointer_ == NONE)
drag_view_ = nullptr;
}
void ShelfView::LayoutToIdealBounds() {
if (bounds_animator_->IsAnimating()) {
AnimateToIdealBounds();
return;
}
gfx::Rect overflow_bounds;
CalculateIdealBounds(&overflow_bounds);
views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
overflow_button_->SetBoundsRect(overflow_bounds);
}
void ShelfView::UpdateShelfItemBackground(SkColor color) {
GetAppListButton()->UpdateShelfItemBackground(color);
overflow_button_->UpdateShelfItemBackground(color);
}
double ShelfView::GetAppListButtonAnimationCurrentValue() {
DCHECK(bounds_animator_);
const gfx::SlideAnimation* animation =
bounds_animator_->GetAnimationForView(GetAppListButton());
if (!animation)
return 0.0;
return animation->GetCurrentValue();
}
void ShelfView::UpdateAllButtonsVisibilityInOverflowMode() {
// The overflow button is not shown in overflow mode.
overflow_button_->SetVisible(false);
DCHECK_LT(last_visible_index_, view_model_->view_size());
for (int i = 0; i < view_model_->view_size(); ++i) {
bool visible = i >= first_visible_index_ && i <= last_visible_index_;
// To track the dragging of |drag_view_| continuously, its visibility
// should be always true regardless of its position.
if (dragged_to_another_shelf_ && view_model_->view_at(i) == drag_view_)
view_model_->view_at(i)->SetVisible(true);
else
view_model_->view_at(i)->SetVisible(visible);
}
}
void ShelfView::CalculateIdealBounds(gfx::Rect* overflow_bounds) const {
DCHECK(model_->item_count() == view_model_->view_size());
int available_size = shelf_->PrimaryAxisValue(width(), height());
int first_panel_index = model_->FirstPanelIndex();
int last_button_index = first_panel_index - 1;
int x = 0;
int y = 0;
int w = shelf_->PrimaryAxisValue(kShelfButtonSize, width());
int h = shelf_->PrimaryAxisValue(height(), kShelfButtonSize);
const bool is_tablet_mode = Shell::Get()->tablet_mode_controller()
? Shell::Get()
->tablet_mode_controller()
->IsTabletModeWindowManagerEnabled()
: false;
for (int i = 0; i < view_model_->view_size(); ++i) {
if (i < first_visible_index_) {
view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
continue;
}
int width = w;
int height = h;
// If this is the app list button and we are in tablet mode, make space for
// the back button (which is part of the app list button).
if (i == 0 && is_tablet_mode) {
width = shelf_->PrimaryAxisValue(2 * w, w);
height = shelf_->PrimaryAxisValue(h, 2 * h);
}
view_model_->set_ideal_bounds(i, gfx::Rect(x, y, width, height));
x = shelf_->PrimaryAxisValue(x + width + kShelfButtonSpacing, x);
y = shelf_->PrimaryAxisValue(y, y + height + kShelfButtonSpacing);
}
if (is_overflow_mode()) {
const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
return;
}
// Right aligned icons.
int end_position = available_size;
x = shelf_->PrimaryAxisValue(end_position, 0);
y = shelf_->PrimaryAxisValue(0, end_position);
for (int i = view_model_->view_size() - 1; i >= first_panel_index; --i) {
x = shelf_->PrimaryAxisValue(x - w - kShelfButtonSpacing, x);
y = shelf_->PrimaryAxisValue(y, y - h - kShelfButtonSpacing);
view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
end_position = shelf_->PrimaryAxisValue(x, y);
}
// Icons on the left / top are guaranteed up to kLeftIconProportion of
// the available space.
int last_icon_position =
shelf_->PrimaryAxisValue(
view_model_->ideal_bounds(last_button_index).right(),
view_model_->ideal_bounds(last_button_index).bottom()) +
kShelfButtonSpacing;
int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
if (last_icon_position < reserved_icon_space)
end_position = last_icon_position;
else
end_position = std::max(end_position, reserved_icon_space);
overflow_bounds->set_size(gfx::Size(shelf_->PrimaryAxisValue(w, width()),
shelf_->PrimaryAxisValue(height(), h)));
last_visible_index_ =
DetermineLastVisibleIndex(end_position - kShelfButtonSpacing);
last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
bool show_overflow = last_visible_index_ < last_button_index ||
last_hidden_index_ >= first_panel_index;
// Create Space for the overflow button
if (show_overflow) {
// The following code makes sure that platform apps icons (aligned to left /
// top) are favored over panel apps icons (aligned to right / bottom).
if (last_visible_index_ > 0 && last_visible_index_ < last_button_index) {
// This condition means that we will take one platform app and replace it
// with the overflow button and put the app in the overflow bubble.
// This happens when the space needed for platform apps exceeds the
// reserved area for non-panel icons,
// (i.e. |last_icon_position| > |reserved_icon_space|).
--last_visible_index_;
} else if (last_hidden_index_ >= first_panel_index &&
last_hidden_index_ < view_model_->view_size() - 1) {
// This condition means that we will take a panel app icon and replace it
// with the overflow button.
// This happens when there is still room for platform apps in the reserved
// area for non-panel icons,
// (i.e. |last_icon_position| < |reserved_icon_space|).
++last_hidden_index_;
}
}
for (int i = 0; i < view_model_->view_size(); ++i) {
bool visible = i <= last_visible_index_ || i > last_hidden_index_;
// To receive drag event continuously from |drag_view_| during the dragging
// off from the shelf, don't make |drag_view_| invisible. It will be
// eventually invisible and removed from the |view_model_| by
// FinalizeRipOffDrag().
if (dragged_off_shelf_ && view_model_->view_at(i) == drag_view_)
continue;
view_model_->view_at(i)->SetVisible(visible);
}
overflow_button_->SetVisible(show_overflow);
if (show_overflow) {
DCHECK_NE(0, view_model_->view_size());
if (last_visible_index_ == -1) {
x = 0;
y = 0;
} else {
x = shelf_->PrimaryAxisValue(
view_model_->ideal_bounds(last_visible_index_).right(),
view_model_->ideal_bounds(last_visible_index_).x());
y = shelf_->PrimaryAxisValue(
view_model_->ideal_bounds(last_visible_index_).y(),
view_model_->ideal_bounds(last_visible_index_).bottom());
}
if (last_visible_index_ >= 0) {
// Add more space between last visible item and overflow button.
// Without this, two buttons look too close compared with other items.
x = shelf_->PrimaryAxisValue(x + kShelfButtonSpacing, x);
y = shelf_->PrimaryAxisValue(y, y + kShelfButtonSpacing);
}
// Set all hidden panel icon positions to be on the overflow button.
for (int i = first_panel_index; i <= last_hidden_index_; ++i)
view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
overflow_bounds->set_x(x);
overflow_bounds->set_y(y);
if (overflow_bubble_.get() && overflow_bubble_->IsShowing())
UpdateOverflowRange(overflow_bubble_->shelf_view());
} else {
if (overflow_bubble_)
overflow_bubble_->Hide();
}
}
int ShelfView::DetermineLastVisibleIndex(int max_value) const {
int index = model_->FirstPanelIndex() - 1;
while (index >= 0 &&
shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).right(),
view_model_->ideal_bounds(index).bottom()) >
max_value) {
index--;
}
return index;
}
int ShelfView::DetermineFirstVisiblePanelIndex(int min_value) const {
int index = model_->FirstPanelIndex();
while (index < view_model_->view_size() &&
shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).x(),
view_model_->ideal_bounds(index).y()) <
min_value) {
++index;
}
return index;
}
void ShelfView::AnimateToIdealBounds() {
gfx::Rect overflow_bounds;
CalculateIdealBounds(&overflow_bounds);
for (int i = 0; i < view_model_->view_size(); ++i) {
View* view = view_model_->view_at(i);
bounds_animator_->AnimateViewTo(view, view_model_->ideal_bounds(i));
// Now that the item animation starts, we have to make sure that the
// padding of the first gets properly transferred to the new first item.
if (i && view->border())
view->SetBorder(views::NullBorder());
if (view == GetAppListButton())
GetAppListButton()->OnBoundsAnimationStarted();
}
overflow_button_->SetBoundsRect(overflow_bounds);
}
views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
views::View* view = nullptr;
switch (item.type) {
case TYPE_APP_PANEL:
case TYPE_PINNED_APP:
case TYPE_BROWSER_SHORTCUT:
case TYPE_APP:
case TYPE_DIALOG: {
ShelfButton* button = new ShelfButton(this, this);
button->SetImage(item.image);
ReflectItemStatus(item, button);
view = button;
break;
}
case TYPE_APP_LIST: {
view = new AppListButton(this, this, shelf_);
break;
}
case TYPE_UNDEFINED:
return nullptr;
}
view->set_context_menu_controller(this);
ConfigureChildView(view);
return view;
}
void ShelfView::FadeIn(views::View* view) {
view->SetVisible(true);
view->layer()->SetOpacity(0);
AnimateToIdealBounds();
bounds_animator_->SetAnimationDelegate(
view, std::unique_ptr<gfx::AnimationDelegate>(
new FadeInAnimationDelegate(view)));
}
void ShelfView::PrepareForDrag(Pointer pointer, const ui::LocatedEvent& event) {
DCHECK(!dragging());
DCHECK(drag_view_);
drag_pointer_ = pointer;
start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
if (start_drag_index_ == -1) {
CancelDrag(-1);
return;
}
// Move the view to the front so that it appears on top of other views.
ReorderChildView(drag_view_, -1);
bounds_animator_->StopAnimatingView(drag_view_);
drag_view_->OnDragStarted(&event);
}
void ShelfView::ContinueDrag(const ui::LocatedEvent& event) {
DCHECK(dragging());
DCHECK(drag_view_);
// Due to a syncing operation the application might have been removed.
// Bail if it is gone.
int current_index = view_model_->GetIndexOfView(drag_view_);
DCHECK_NE(-1, current_index);
// If this is not a drag and drop host operation and not the app list item,
// check if the item got ripped off the shelf - if it did we are done.
if (drag_and_drop_shelf_id_.IsNull() &&
RemovableByRipOff(current_index) != NOT_REMOVABLE) {
if (HandleRipOffDrag(event))
return;
// The rip off handler could have changed the location of the item.
current_index = view_model_->GetIndexOfView(drag_view_);
}
// TODO: I don't think this works correctly with RTL.
gfx::Point drag_point(event.location());
ConvertPointToTarget(drag_view_, this, &drag_point);
// Constrain the location to the range of valid indices for the type.
std::pair<int, int> indices(GetDragRange(current_index));
int first_drag_index = indices.first;
int last_drag_index = indices.second;
// If the last index isn't valid, we're overflowing. Constrain to the app list
// (which is the last visible item).
if (first_drag_index < model_->FirstPanelIndex() &&
last_drag_index > last_visible_index_)
last_drag_index = last_visible_index_;
int x = 0, y = 0;
if (shelf_->IsHorizontalAlignment()) {
x = std::max(view_model_->ideal_bounds(indices.first).x(),
drag_point.x() - drag_origin_.x());
x = std::min(view_model_->ideal_bounds(last_drag_index).right() -
view_model_->ideal_bounds(current_index).width(),
x);
if (drag_view_->x() == x)
return;
drag_view_->SetX(x);
} else {
y = std::max(view_model_->ideal_bounds(indices.first).y(),
drag_point.y() - drag_origin_.y());
y = std::min(view_model_->ideal_bounds(last_drag_index).bottom() -
view_model_->ideal_bounds(current_index).height(),
y);
if (drag_view_->y() == y)
return;
drag_view_->SetY(y);
}
int target_index = views::ViewModelUtils::DetermineMoveIndex(
*view_model_, drag_view_,
shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
: views::ViewModelUtils::VERTICAL,
x, y);
target_index =
std::min(indices.second, std::max(target_index, indices.first));
// The app list button is always first, and it is the only non-draggable item.
int first_draggable_item = model_->GetItemIndexForType(TYPE_APP_LIST) + 1;
DCHECK_EQ(1, first_draggable_item);
target_index = std::max(target_index, first_draggable_item);
DCHECK_LT(target_index, model_->item_count());
if (target_index == current_index)
return;
// Change the model, the ShelfItemMoved() callback will handle the
// |view_model_| update.
model_->Move(current_index, target_index);
bounds_animator_->StopAnimatingView(drag_view_);
}
void ShelfView::EndDragOnOtherShelf(bool cancel) {
if (is_overflow_mode()) {
main_shelf_->EndDrag(cancel);
} else {
DCHECK(overflow_bubble_->IsShowing());
overflow_bubble_->shelf_view()->EndDrag(cancel);
}
}
bool ShelfView::HandleRipOffDrag(const ui::LocatedEvent& event) {
int current_index = view_model_->GetIndexOfView(drag_view_);
DCHECK_NE(-1, current_index);
std::string dragged_app_id = model_->items()[current_index].id.app_id;
gfx::Point screen_location = event.root_location();
::wm::ConvertPointToScreen(GetWidget()->GetNativeWindow()->GetRootWindow(),
&screen_location);
// To avoid ugly forwards and backwards flipping we use different constants
// for ripping off / re-inserting the items.
if (dragged_off_shelf_) {
// If the shelf/overflow bubble bounds contains |screen_location| we insert
// the item back into the shelf.
if (GetBoundsForDragInsertInScreen().Contains(screen_location)) {
if (dragged_to_another_shelf_) {
// During the dragging an item from Shelf to Overflow, it can enter here
// directly because both are located very closely.
EndDragOnOtherShelf(true /* cancel */);
// Stops the animation of |drag_view_| and sets its bounds explicitly
// because ContinueDrag() stops its animation. Without this, unexpected
// bounds will be set.
bounds_animator_->StopAnimatingView(drag_view_);
int drag_view_index = view_model_->GetIndexOfView(drag_view_);
drag_view_->SetBoundsRect(view_model_->ideal_bounds(drag_view_index));
dragged_to_another_shelf_ = false;
}
// Destroy our proxy view item.
DestroyDragIconProxy();
// Re-insert the item and return simply false since the caller will handle
// the move as in any normal case.
dragged_off_shelf_ = false;
drag_view_->layer()->SetOpacity(1.0f);
// The size of Overflow bubble should be updated immediately when an item
// is re-inserted.
if (is_overflow_mode())
PreferredSizeChanged();
return false;
} else if (is_overflow_mode() &&
main_shelf_->GetBoundsForDragInsertInScreen().Contains(
screen_location)) {
// The item was dragged from the overflow shelf to the main shelf.
if (!dragged_to_another_shelf_) {
dragged_to_another_shelf_ = true;
drag_image_->SetOpacity(1.0f);
main_shelf_->StartDrag(dragged_app_id, screen_location);
} else {
main_shelf_->Drag(screen_location);
}
} else if (!is_overflow_mode() && overflow_bubble_ &&
overflow_bubble_->IsShowing() &&
overflow_bubble_->shelf_view()
->GetBoundsForDragInsertInScreen()
.Contains(screen_location)) {
// The item was dragged from the main shelf to the overflow shelf.
if (!dragged_to_another_shelf_) {
dragged_to_another_shelf_ = true;
drag_image_->SetOpacity(1.0f);
overflow_bubble_->shelf_view()->StartDrag(dragged_app_id,
screen_location);
} else {
overflow_bubble_->shelf_view()->Drag(screen_location);
}
} else if (dragged_to_another_shelf_) {
// Makes the |drag_image_| partially disappear again.
dragged_to_another_shelf_ = false;
drag_image_->SetOpacity(kDraggedImageOpacity);
EndDragOnOtherShelf(true /* cancel */);
if (!is_overflow_mode()) {
// During dragging, the position of the dragged item is moved to the
// back. If the overflow bubble is showing, a copy of the dragged item
// will appear at the end of the overflow shelf. Decrement the last
// visible index of the overflow shelf to hide this copy.
overflow_bubble_->shelf_view()->last_visible_index_--;
}
bounds_animator_->StopAnimatingView(drag_view_);
int drag_view_index = view_model_->GetIndexOfView(drag_view_);
drag_view_->SetBoundsRect(view_model_->ideal_bounds(drag_view_index));
}
// Move our proxy view item.
UpdateDragIconProxy(screen_location);
return true;
}
// Mark the item as dragged off the shelf if the drag distance exceeds
// |kRipOffDistance|, or if it's dragged between the main and overflow shelf.
int delta = CalculateShelfDistance(screen_location);
bool dragged_off_shelf = delta > kRipOffDistance;
dragged_off_shelf |=
(is_overflow_mode() &&
main_shelf_->GetBoundsForDragInsertInScreen().Contains(screen_location));
dragged_off_shelf |= (!is_overflow_mode() && overflow_bubble_ &&
overflow_bubble_->IsShowing() &&
overflow_bubble_->shelf_view()
->GetBoundsForDragInsertInScreen()
.Contains(screen_location));
if (dragged_off_shelf) {
// Create a proxy view item which can be moved anywhere.
CreateDragIconProxy(event.root_location(), drag_view_->GetImage(),
drag_view_, gfx::Vector2d(0, 0),
kDragAndDropProxyScale);
drag_view_->layer()->SetOpacity(0.0f);
dragged_off_shelf_ = true;
if (RemovableByRipOff(current_index) == REMOVABLE) {
// Move the item to the front of the first panel item and hide it.
// ShelfItemMoved() callback will handle the |view_model_| update and
// call AnimateToIdealBounds().
if (current_index != model_->FirstPanelIndex() - 1) {
model_->Move(current_index, model_->FirstPanelIndex() - 1);
StartFadeInLastVisibleItem();
// During dragging, the position of the dragged item is moved to the
// back. If the overflow bubble is showing, a copy of the dragged item
// will appear at the end of the overflow shelf. Decrement the last
// visible index of the overflow shelf to hide this copy.
if (overflow_bubble_ && overflow_bubble_->IsShowing())
overflow_bubble_->shelf_view()->last_visible_index_--;
} else if (is_overflow_mode()) {
// Overflow bubble should be shrunk when an item is ripped off.
PreferredSizeChanged();
}
// Make the item partially disappear to show that it will get removed if
// dropped.
drag_image_->SetOpacity(kDraggedImageOpacity);
}
return true;
}
return false;
}
void ShelfView::FinalizeRipOffDrag(bool cancel) {
if (!dragged_off_shelf_)
return;
// Make sure we do not come in here again.
dragged_off_shelf_ = false;
// Coming here we should always have a |drag_view_|.
DCHECK(drag_view_);
int current_index = view_model_->GetIndexOfView(drag_view_);
// If the view isn't part of the model anymore (|current_index| == -1), a sync
// operation must have removed it. In that case we shouldn't change the model
// and only delete the proxy image.
if (current_index == -1) {
DestroyDragIconProxy();
return;
}
// Set to true when the animation should snap back to where it was before.
bool snap_back = false;
// Items which cannot be dragged off will be handled as a cancel.
if (!cancel) {
if (dragged_to_another_shelf_) {
dragged_to_another_shelf_ = false;
EndDragOnOtherShelf(false /* cancel */);
drag_view_->layer()->SetOpacity(1.0f);
} else if (RemovableByRipOff(current_index) != REMOVABLE) {
// Make sure we do not try to remove un-removable items like items which
// were not pinned or have to be always there.
cancel = true;
snap_back = true;
} else {
// Make sure the item stays invisible upon removal.
drag_view_->SetVisible(false);
model_->UnpinAppWithID(model_->items()[current_index].id.app_id);
}
}
if (cancel || snap_back) {
if (dragged_to_another_shelf_) {
dragged_to_another_shelf_ = false;
// Other shelf handles revert of dragged item.
EndDragOnOtherShelf(false /* true */);
drag_view_->layer()->SetOpacity(1.0f);
} else if (!cancelling_drag_model_changed_) {
// Only do something if the change did not come through a model change.
gfx::Rect drag_bounds = drag_image_->GetBoundsInScreen();
gfx::Point relative_to = GetBoundsInScreen().origin();
gfx::Rect target(
gfx::PointAtOffsetFromOrigin(drag_bounds.origin() - relative_to),
drag_bounds.size());
drag_view_->SetBoundsRect(target);
// Hide the status from the active item since we snap it back now. Upon
// animation end the flag gets cleared if |snap_back_from_rip_off_view_|
// is set.
snap_back_from_rip_off_view_ = drag_view_;
drag_view_->AddState(ShelfButton::STATE_HIDDEN);
// When a canceling drag model is happening, the view model is diverged
// from the menu model and movements / animations should not be done.
model_->Move(current_index, start_drag_index_);
AnimateToIdealBounds();
}
drag_view_->layer()->SetOpacity(1.0f);
}
DestroyDragIconProxy();
}
ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) const {
DCHECK(index >= 0 && index < model_->item_count());
ShelfItemType type = model_->items()[index].type;
if (type == TYPE_APP_LIST || type == TYPE_DIALOG)
return NOT_REMOVABLE;
if (model_->items()[index].pinned_by_policy)
return NOT_REMOVABLE;
// Note: Only pinned app shortcuts can be removed!
const std::string& app_id = model_->items()[index].id.app_id;
return (type == TYPE_PINNED_APP && model_->IsAppPinned(app_id)) ? REMOVABLE
: DRAGGABLE;
}
bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
switch (typea) {
case TYPE_PINNED_APP:
case TYPE_BROWSER_SHORTCUT:
return (typeb == TYPE_PINNED_APP || typeb == TYPE_BROWSER_SHORTCUT);
case TYPE_APP_PANEL:
case TYPE_APP_LIST:
case TYPE_APP:
case TYPE_DIALOG:
return typeb == typea;
case TYPE_UNDEFINED:
NOTREACHED() << "ShelfItemType must be set.";
return false;
}
NOTREACHED();
return false;
}
std::pair<int, int> ShelfView::GetDragRange(int index) {
int min_index = -1;
int max_index = -1;
ShelfItemType type = model_->items()[index].type;
for (int i = 0; i < model_->item_count(); ++i) {
if (SameDragType(model_->items()[i].type, type)) {
if (min_index == -1)
min_index = i;
max_index = i;
}
}
return std::pair<int, int>(min_index, max_index);
}
void ShelfView::ConfigureChildView(views::View* view) {
view->SetPaintToLayer();
view->layer()->SetFillsBoundsOpaquely(false);
}
void ShelfView::ToggleOverflowBubble() {
if (IsShowingOverflowBubble()) {
overflow_bubble_->Hide();
return;
}
if (!overflow_bubble_)
overflow_bubble_.reset(new OverflowBubble(shelf_));
ShelfView* overflow_view = new ShelfView(model_, shelf_, shelf_widget_);
overflow_view->overflow_mode_ = true;
overflow_view->Init();
overflow_view->set_owner_overflow_bubble(overflow_bubble_.get());
overflow_view->OnShelfAlignmentChanged();
overflow_view->main_shelf_ = this;
UpdateOverflowRange(overflow_view);
overflow_bubble_->Show(overflow_button_, overflow_view);
shelf_->UpdateVisibilityState();
}
void ShelfView::OnFadeOutAnimationEnded() {
AnimateToIdealBounds();
StartFadeInLastVisibleItem();
}
void ShelfView::StartFadeInLastVisibleItem() {
// If overflow button is visible and there is a valid new last item, fading
// the new last item in after sliding animation is finished.
if (overflow_button_->visible() && last_visible_index_ >= 0) {
views::View* last_visible_view = view_model_->view_at(last_visible_index_);
last_visible_view->layer()->SetOpacity(0);
bounds_animator_->SetAnimationDelegate(
last_visible_view,
std::unique_ptr<gfx::AnimationDelegate>(
new StartFadeAnimationDelegate(this, last_visible_view)));
}
}
void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) const {
const int first_overflow_index = last_visible_index_ + 1;
const int last_overflow_index = last_hidden_index_;
DCHECK_LE(first_overflow_index, last_overflow_index);
DCHECK_LT(last_overflow_index, view_model_->view_size());
overflow_view->first_visible_index_ = first_overflow_index;
overflow_view->last_visible_index_ = last_overflow_index;
}
gfx::Rect ShelfView::GetBoundsForDragInsertInScreen() {
gfx::Size preferred_size;
if (is_overflow_mode()) {
DCHECK(owner_overflow_bubble_);
gfx::Rect bubble_bounds =
owner_overflow_bubble_->bubble_view()->GetBubbleBounds();
preferred_size = bubble_bounds.size();
} else {
const int last_button_index = view_model_->view_size() - 1;
gfx::Rect last_button_bounds =
view_model_->view_at(last_button_index)->bounds();
if (overflow_button_->visible() &&
model_->GetItemIndexForType(TYPE_APP_PANEL) == -1) {
// When overflow button is visible and shelf has no panel items,
// last_button_bounds should be overflow button's bounds.
last_button_bounds = overflow_button_->bounds();
}
if (shelf_->IsHorizontalAlignment()) {
preferred_size = gfx::Size(last_button_bounds.right(), kShelfSize);
} else {
preferred_size = gfx::Size(kShelfSize, last_button_bounds.bottom());
}
}
gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
// In overflow mode, we should use OverflowBubbleView as a source for
// converting |origin| to screen coordinates. When a scroll operation is
// occurred in OverflowBubble, the bounds of ShelfView in OverflowBubble can
// be changed.
if (is_overflow_mode())
ConvertPointToScreen(owner_overflow_bubble_->bubble_view(), &origin);
else
ConvertPointToScreen(this, &origin);
return gfx::Rect(origin, preferred_size);
}
int ShelfView::CancelDrag(int modified_index) {
FinalizeRipOffDrag(true);
if (!drag_view_)
return modified_index;
bool was_dragging = dragging();
int drag_view_index = view_model_->GetIndexOfView(drag_view_);
drag_pointer_ = NONE;
drag_view_ = nullptr;
if (drag_view_index == modified_index) {
// The view that was being dragged is being modified. Don't do anything.
return modified_index;
}
if (!was_dragging)
return modified_index;
// Restore previous position, tracking the position of the modified view.
bool at_end = modified_index == view_model_->view_size();
views::View* modified_view = (modified_index >= 0 && !at_end)
? view_model_->view_at(modified_index)
: nullptr;
model_->Move(drag_view_index, start_drag_index_);
// If the modified view will be at the end of the list, return the new end of
// the list.
if (at_end)
return view_model_->view_size();
return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
}
gfx::Size ShelfView::CalculatePreferredSize() const {
gfx::Rect overflow_bounds;
CalculateIdealBounds(&overflow_bounds);
int last_button_index = last_visible_index_;
if (!is_overflow_mode()) {
if (last_hidden_index_ < view_model_->view_size() - 1)
last_button_index = view_model_->view_size() - 1;
else if (overflow_button_ && overflow_button_->visible())
last_button_index++;
}
// When an item is dragged off from the overflow bubble, it is moved to last
// position and and changed to invisible. Overflow bubble size should be
// shrunk to fit only for visible items.
// If |dragged_to_another_shelf_| is set, there will be no
// invisible items in the shelf.
if (is_overflow_mode() && dragged_off_shelf_ && !dragged_to_another_shelf_ &&
RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
last_button_index--;
const gfx::Rect last_button_bounds =
last_button_index >= first_visible_index_
? view_model_->ideal_bounds(last_button_index)
: gfx::Rect(gfx::Size(kShelfSize, kShelfSize));
if (shelf_->IsHorizontalAlignment())
return gfx::Size(last_button_bounds.right(), kShelfSize);
return gfx::Size(kShelfSize, last_button_bounds.bottom());
}
void ShelfView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
// This bounds change is produced by the shelf movement (rotation, alignment
// change, etc.) and all content has to follow. Using an animation at that
// time would produce a time lag since the animation of the BoundsAnimator has
// itself a delay before it arrives at the required location. As such we tell
// the animator to go there immediately. We still want to use an animation
// when the bounds change is caused by entering or exiting tablet mode.
if (shelf_->is_tablet_mode_animation_running()) {
AnimateToIdealBounds();
return;
}
BoundsAnimatorDisabler disabler(bounds_animator_.get());
LayoutToIdealBounds();
shelf_->NotifyShelfIconPositionsChanged();
if (IsShowingOverflowBubble())
overflow_bubble_->Hide();
}
views::FocusTraversable* ShelfView::GetPaneFocusTraversable() {
return this;
}
void ShelfView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
node_data->role = ui::AX_ROLE_TOOLBAR;
node_data->SetName(l10n_util::GetStringUTF8(IDS_ASH_SHELF_ACCESSIBLE_NAME));
}
void ShelfView::ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) {
if (details.is_add && details.child == this)
tooltip_.Init();
}
void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
// Convert the event location from current view to screen, since swiping up on
// the shelf can open the fullscreen app list. Updating the bounds of the app
// list during dragging is based on screen coordinate space.
gfx::Point location_in_screen(event->location());
View::ConvertPointToScreen(this, &location_in_screen);
event->set_location(location_in_screen);
if (shelf_->ProcessGestureEvent(*event))
event->StopPropagation();
}
bool ShelfView::OnMouseWheel(const ui::MouseWheelEvent& event) {
shelf_->ProcessMouseWheelEvent(event);
return true;
}
void ShelfView::ShelfItemAdded(int model_index) {
{
base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
true);
model_index = CancelDrag(model_index);
}
views::View* view = CreateViewForItem(model_->items()[model_index]);
AddChildView(view);
// Hide the view, it'll be made visible when the animation is done. Using
// opacity 0 here to avoid messing with CalculateIdealBounds which touches
// the view's visibility.
view->layer()->SetOpacity(0);
view_model_->Add(view, model_index);
// Give the button its ideal bounds. That way if we end up animating the
// button before this animation completes it doesn't appear at some random
// spot (because it was in the middle of animating from 0,0 0x0 to its
// target).
gfx::Rect overflow_bounds;
CalculateIdealBounds(&overflow_bounds);
view->SetBoundsRect(view_model_->ideal_bounds(model_index));
// The first animation moves all the views to their target position. |view|
// is hidden, so it visually appears as though we are providing space for
// it. When done we'll fade the view in.
AnimateToIdealBounds();
if (model_index <= last_visible_index_ ||
model_index >= model_->FirstPanelIndex()) {
bounds_animator_->SetAnimationDelegate(
view, std::unique_ptr<gfx::AnimationDelegate>(
new StartFadeAnimationDelegate(this, view)));
} else {
// Undo the hiding if animation does not run.
view->layer()->SetOpacity(1.0f);
}
}
void ShelfView::ShelfItemRemoved(int model_index, const ShelfItem& old_item) {
if (old_item.id == context_menu_id_)
launcher_menu_runner_->Cancel();
views::View* view = view_model_->view_at(model_index);
view_model_->Remove(model_index);
{
base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
true);
CancelDrag(-1);
}
// When the overflow bubble is visible, the overflow range needs to be set
// before CalculateIdealBounds() gets called. Otherwise CalculateIdealBounds()
// could trigger a ShelfItemChanged() by hiding the overflow bubble and
// since the overflow bubble is not yet synced with the ShelfModel this
// could cause a crash.
if (overflow_bubble_ && overflow_bubble_->IsShowing()) {
last_hidden_index_ =
std::min(last_hidden_index_, view_model_->view_size() - 1);
UpdateOverflowRange(overflow_bubble_->shelf_view());
}
if (view->visible()) {
// The first animation fades out the view. When done we'll animate the rest
// of the views to their target location.
bounds_animator_->AnimateViewTo(view, view->bounds());
bounds_animator_->SetAnimationDelegate(
view, std::unique_ptr<gfx::AnimationDelegate>(
new FadeOutAnimationDelegate(this, view)));
} else {
// We don't need to show a fade out animation for invisible |view|. When an
// item is ripped out from the shelf, its |view| is already invisible.
AnimateToIdealBounds();
}
if (view == tooltip_.GetCurrentAnchorView())
tooltip_.Close();
}
void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
const ShelfItem& item(model_->items()[model_index]);
// Bail if the view and shelf sizes do not match. ShelfItemChanged may be
// called here before ShelfItemAdded, due to ChromeLauncherController's
// item initialization, which calls SetItem during ShelfItemAdded.
if (static_cast<int>(model_->items().size()) != view_model_->view_size())
return;
if (old_item.type != item.type) {
// Type changed, swap the views.
model_index = CancelDrag(model_index);
std::unique_ptr<views::View> old_view(view_model_->view_at(model_index));
bounds_animator_->StopAnimatingView(old_view.get());
// Removing and re-inserting a view in our view model will strip the ideal
// bounds from the item. To avoid recalculation of everything the bounds
// get remembered and restored after the insertion to the previous value.
gfx::Rect old_ideal_bounds = view_model_->ideal_bounds(model_index);
view_model_->Remove(model_index);
views::View* new_view = CreateViewForItem(item);
AddChildView(new_view);
view_model_->Add(new_view, model_index);
view_model_->set_ideal_bounds(model_index, old_ideal_bounds);
new_view->SetBoundsRect(old_view->bounds());
if (overflow_button_ && overflow_button_->visible())
AnimateToIdealBounds();
else
bounds_animator_->AnimateViewTo(new_view, old_ideal_bounds);
return;
}
views::View* view = view_model_->view_at(model_index);
switch (item.type) {
case TYPE_APP_PANEL:
case TYPE_PINNED_APP:
case TYPE_BROWSER_SHORTCUT:
case TYPE_APP:
case TYPE_DIALOG: {
CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
ShelfButton* button = static_cast<ShelfButton*>(view);
ReflectItemStatus(item, button);
button->SetImage(item.image);
button->SchedulePaint();
break;
}
default:
break;
}
}
void ShelfView::ShelfItemMoved(int start_index, int target_index) {
view_model_->Move(start_index, target_index);
// When cancelling a drag due to a shelf item being added, the currently
// dragged item is moved back to its initial position. AnimateToIdealBounds
// will be called again when the new item is added to the |view_model_| but
// at this time the |view_model_| is inconsistent with the |model_|.
if (!cancelling_drag_model_changed_)
AnimateToIdealBounds();
}
void ShelfView::ShelfItemDelegateChanged(const ShelfID& id,
ShelfItemDelegate* old_delegate,
ShelfItemDelegate* delegate) {}
void ShelfView::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) {
shelf_button_pressed_metric_tracker_.ButtonPressed(*event, sender, action);
// The app list handles its own ink drop effect state changes.
if (action != SHELF_ACTION_APP_LIST_SHOWN) {
if (action != SHELF_ACTION_NEW_WINDOW_CREATED && menu_items &&
menu_items->size() > 1) {
// Show the app menu with 2 or more items, if no window was created.
ink_drop->AnimateToState(views::InkDropState::ACTIVATED);
context_menu_id_ = item.id;
ShowMenu(std::make_unique<ShelfApplicationMenuModel>(
item.title, std::move(*menu_items),
model_->GetShelfItemDelegate(item.id)),
sender, gfx::Point(), false,
ui::GetMenuSourceTypeForEvent(*event), ink_drop);
} else {
ink_drop->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
}
}
scoped_root_window_for_new_windows_.reset();
}
void ShelfView::AfterGetContextMenuItems(
const ShelfID& shelf_id,
const gfx::Point& point,
views::View* source,
ui::MenuSourceType source_type,
std::vector<mojom::MenuItemPtr> menu_items) {
context_menu_id_ = shelf_id;
const int64_t display_id = GetDisplayIdForView(this);
ShowMenu(std::make_unique<ShelfContextMenuModel>(
std::move(menu_items), model_->GetShelfItemDelegate(shelf_id),
display_id),
source, point, true /* context_menu */, source_type,
nullptr /* ink_drop */);
}
void ShelfView::ShowContextMenuForView(views::View* source,
const gfx::Point& point,
ui::MenuSourceType source_type) {
gfx::Point context_menu_point = point;
aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
// Align the context menu to the edge of the shelf for touch events.
if (source_type == ui::MenuSourceType::MENU_SOURCE_TOUCH) {
gfx::Rect shelf_bounds =
is_overflow_mode()
? owner_overflow_bubble_->bubble_view()->GetBubbleBounds()
: ScreenUtil::GetDisplayBoundsWithShelf(shelf_window);
switch (shelf_->alignment()) {
case SHELF_ALIGNMENT_BOTTOM:
case SHELF_ALIGNMENT_BOTTOM_LOCKED:
context_menu_point.SetPoint(point.x(),
shelf_bounds.bottom() - kShelfSize);
break;
case SHELF_ALIGNMENT_LEFT:
context_menu_point.SetPoint(shelf_bounds.x() + kShelfSize, point.y());
break;
case SHELF_ALIGNMENT_RIGHT:
context_menu_point.SetPoint(shelf_bounds.right() - kShelfSize,
point.y());
break;
}
}
last_pressed_index_ = -1;
const int64_t display_id = GetDisplayIdForView(this);
const ShelfItem* item = ShelfItemForView(source);
if (!item || !model_->GetShelfItemDelegate(item->id)) {
context_menu_id_ = ShelfID();
ShowMenu(std::make_unique<ShelfContextMenuModel>(
std::vector<mojom::MenuItemPtr>(), nullptr, display_id),
source, context_menu_point, true, source_type, nullptr);
return;
}
// Get any custom entries; show the context menu in AfterGetContextMenuItems.
model_->GetShelfItemDelegate(item->id)->GetContextMenuItems(
display_id, base::Bind(&ShelfView::AfterGetContextMenuItems,
weak_factory_.GetWeakPtr(), item->id,
context_menu_point, source, source_type));
}
void ShelfView::ShowMenu(std::unique_ptr<ui::MenuModel> menu_model,
views::View* source,
const gfx::Point& click_point,
bool context_menu,
ui::MenuSourceType source_type,
views::InkDrop* ink_drop) {
menu_model_ = std::move(menu_model);
menu_model_adapter_.reset(new views::MenuModelAdapter(
menu_model_.get(),
base::Bind(&ShelfView::OnMenuClosed, base::Unretained(this), ink_drop)));
closing_event_time_ = base::TimeTicks();
int run_types = 0;
if (context_menu)
run_types |=
views::MenuRunner::CONTEXT_MENU | views::MenuRunner::FIXED_ANCHOR;
// Only selected shelf items with context menu opened can be dragged.
const ShelfItem* item = ShelfItemForView(source);
if (context_menu && item && item->type != TYPE_APP_LIST &&
source_type == ui::MenuSourceType::MENU_SOURCE_TOUCH) {
run_types |= views::MenuRunner::SEND_GESTURE_EVENTS_TO_OWNER;
}
launcher_menu_runner_.reset(
new views::MenuRunner(menu_model_adapter_->CreateMenu(), run_types));
views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
gfx::Rect anchor = gfx::Rect(click_point, gfx::Size());
if (!context_menu) {
DCHECK(source) << "Application lists require a source button view.";
// Application lists use a bubble.
// It is possible to invoke the menu while it is sliding into view. To cover
// that case, the screen coordinates are offsetted by the animation delta.
aura::Window* window = GetWidget()->GetNativeWindow();
anchor = source->GetBoundsInScreen() +
(window->GetTargetBounds().origin() - window->bounds().origin());
// Adjust the anchor location for shelf items with asymmetrical borders.
if (source->border())
anchor.Inset(source->border()->GetInsets());
// Determine the menu alignment dependent on the shelf.
switch (shelf_->alignment()) {
case SHELF_ALIGNMENT_BOTTOM:
case SHELF_ALIGNMENT_BOTTOM_LOCKED:
menu_alignment = views::MENU_ANCHOR_BUBBLE_ABOVE;
break;
case SHELF_ALIGNMENT_LEFT:
menu_alignment = views::MENU_ANCHOR_BUBBLE_RIGHT;
break;
case SHELF_ALIGNMENT_RIGHT:
menu_alignment = views::MENU_ANCHOR_BUBBLE_LEFT;
break;
}
} else {
// Distinguish the touch events that triggered on the bottom or left / right
// shelf. Since they should have different |MenuAnchorPosition|.
if (shelf_->IsHorizontalAlignment())
menu_alignment = views::MENU_ANCHOR_FIXED_BOTTOMCENTER;
else
menu_alignment = views::MENU_ANCHOR_FIXED_SIDECENTER;
}
// NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
launcher_menu_runner_->RunMenuAt(GetWidget(), nullptr, anchor, menu_alignment,
source_type);
}
void ShelfView::OnMenuClosed(views::InkDrop* ink_drop) {
context_menu_id_ = ShelfID();
closing_event_time_ = launcher_menu_runner_->closing_event_time();
if (ink_drop)
ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
launcher_menu_runner_.reset();
menu_model_adapter_.reset();
menu_model_.reset();
// Auto-hide or alignment might have changed, but only for this shelf.
shelf_->UpdateVisibilityState();
}
void ShelfView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
shelf_->NotifyShelfIconPositionsChanged();
PreferredSizeChanged();
}
void ShelfView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
shelf_->set_is_tablet_mode_animation_running(false);
if (snap_back_from_rip_off_view_ && animator == bounds_animator_.get()) {
if (!animator->IsAnimating(snap_back_from_rip_off_view_)) {
// Coming here the animation of the ShelfButton is finished and the
// previously hidden status can be shown again. Since the button itself
// might have gone away or changed locations we check that the button
// is still in the shelf and show its status again.
for (int index = 0; index < view_model_->view_size(); index++) {
views::View* view = view_model_->view_at(index);
if (view == snap_back_from_rip_off_view_) {
CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
ShelfButton* button = static_cast<ShelfButton*>(view);
button->ClearState(ShelfButton::STATE_HIDDEN);
break;
}
}
snap_back_from_rip_off_view_ = nullptr;
}
}
if (GetAppListButton())
GetAppListButton()->OnBoundsAnimationFinished();
}
bool ShelfView::IsRepostEvent(const ui::Event& event) {
if (closing_event_time_.is_null())
return false;
// If the current (press down) event is a repost event, the time stamp of
// these two events should be the same.
return closing_event_time_ == event.time_stamp();
}
const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
const int view_index = view_model_->GetIndexOfView(view);
return (view_index < 0) ? nullptr : &(model_->items()[view_index]);
}
int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
const gfx::Rect bounds = GetBoundsInScreen();
int distance = shelf_->SelectValueForShelfAlignment(
bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
bounds.x() - coordinate.x());
return distance > 0 ? distance : 0;
}
bool ShelfView::CanPrepareForDrag(Pointer pointer,
const ui::LocatedEvent& event) {
// Bail if dragging has already begun, or if no item has been pressed.
if (dragging() || !drag_view_)
return false;
// Dragging only begins once the pointer has travelled a minimum distance.
if ((std::abs(event.x() - drag_origin_.x()) < kMinimumDragDistance) &&
(std::abs(event.y() - drag_origin_.y()) < kMinimumDragDistance)) {
return false;
}
return true;
}
} // namespace ash