blob: 959d7cdd7892bad42802a232e2e94b1653dd9e91 [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 "ui/app_list/views/apps_grid_view.h"
#include <algorithm>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "ash/app_list/model/app_list_folder_item.h"
#include "ash/app_list/model/app_list_item.h"
#include "base/guid.h"
#include "base/macros.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/ranges.h"
#include "build/build_config.h"
#include "ui/app_list/app_list_constants.h"
#include "ui/app_list/app_list_features.h"
#include "ui/app_list/app_list_switches.h"
#include "ui/app_list/app_list_util.h"
#include "ui/app_list/app_list_view_delegate.h"
#include "ui/app_list/pagination_controller.h"
#include "ui/app_list/views/app_list_drag_and_drop_host.h"
#include "ui/app_list/views/app_list_folder_view.h"
#include "ui/app_list/views/app_list_item_view.h"
#include "ui/app_list/views/app_list_main_view.h"
#include "ui/app_list/views/apps_container_view.h"
#include "ui/app_list/views/contents_view.h"
#include "ui/app_list/views/expand_arrow_view.h"
#include "ui/app_list/views/indicator_chip_view.h"
#include "ui/app_list/views/page_switcher_horizontal.h"
#include "ui/app_list/views/page_switcher_vertical.h"
#include "ui/app_list/views/pulsing_block_view.h"
#include "ui/app_list/views/search_box_view.h"
#include "ui/app_list/views/search_result_tile_item_view.h"
#include "ui/app_list/views/suggestions_container_view.h"
#include "ui/app_list/views/top_icon_animation_view.h"
#include "ui/aura/window.h"
#include "ui/aura/window_event_dispatcher.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/compositor/layer_animation_element.h"
#include "ui/compositor/paint_recorder.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/events/event.h"
#include "ui/gfx/animation/animation.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/gfx/geometry/vector2d_conversions.h"
#include "ui/gfx/skia_paint_util.h"
#include "ui/strings/grit/ui_strings.h"
#include "ui/views/border.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/view_model_utils.h"
#include "ui/views/widget/widget.h"
namespace app_list {
namespace {
// The preferred width/height for apps grid. For page #01, it includes the
// top/bottom 24px padding. For page #02 and all the followings, it includes top
// 24px padding and bottom 56px padding.
constexpr int kAppsGridPreferredWidth = 576;
constexpr int kAppsGridPreferredHeight = 623;
// 32px page break space adjustment needed to keep 48px page break space due to
// the fact that page #02 and all the followings have bottom 56px padding.
constexpr int kPageBreakSpaceAdjustment = 32;
// Distance a drag needs to be from the app grid to be considered 'outside', at
// which point we rearrange the apps to their pre-drag configuration, as a drop
// then would be canceled. We have a buffer to make it easier to drag apps to
// other pages.
constexpr int kDragBufferPx = 20;
// Padding space in pixels between pages.
constexpr int kPagePadding = 40;
// Preferred tile size when showing in fixed layout.
constexpr int kPreferredTileWidth = 100;
constexpr int kPreferredTileHeight = 100;
// Padding on each side of a tile.
constexpr int kTileLeftRightPadding = 10;
constexpr int kTileBottomPadding = 6;
constexpr int kTileTopPadding = 6;
constexpr int kTileHorizontalPadding = 12;
constexpr int kTileVerticalPadding = 6;
// Width in pixels of the area on the sides that triggers a page flip.
constexpr int kPageFlipZoneSize = 40;
// Delay in milliseconds to do the page flip.
constexpr int kPageFlipDelayInMs = 1000;
// Delay in milliseconds to do the page flip in fullscreen app list.
constexpr int kPageFlipDelayInMsFullscreen = 500;
// The drag and drop proxy should get scaled by this factor.
constexpr float kDragAndDropProxyScale = 1.2f;
// Delays in milliseconds to show folder dropping preview circle.
constexpr int kFolderDroppingDelay = 150;
// Delays in milliseconds to show re-order preview.
constexpr int kReorderDelay = 120;
// Delays in milliseconds to show folder item reparent UI.
constexpr int kFolderItemReparentDelay = 50;
// Radius of the circle, in which if entered, show folder dropping preview
// UI.
constexpr int kFolderDroppingCircleRadius = 39;
// Padding between suggested apps tiles and all apps indicator.
constexpr int kSuggestionsAllAppsIndicatorPadding = 26;
// Padding between all apps indicator and all apps.
constexpr int kAllAppsIndicatorBottomPadding = 2;
// The height of gradient fade-out zones.
constexpr int kFadeoutZoneHeight = 24;
// Range of dragging amount fraction for suggested apps to change opacity from
// 0.f to 1.0f.
constexpr float kSuggestedAppsOpacityStartFraction = 0.3f;
constexpr float kSuggestedAppsOpacityEndFraction = 0.7f;
// Range of dragging amount fraction for all apps indicator to change opacity
// from 0.f to 1.0f.
constexpr float kAllAppsIndicatorOpacityStartFraction = 0.7f;
constexpr float kAllAppsIndicatorOpacityEndFraction = 1.0f;
// Range of dragging amount fraction for expand arrow to change opacity from
// 1.0f to 0.f.
constexpr float kExpandArrowDismissStartFraction = 0.f;
constexpr float kExpandArrowDismissEndFraction = 0.2f;
// Range of dragging amount fraction for expand arrow to change opacity from 0.f
// to 1.0f.
constexpr float kExpandArrowShowStartFraction = 0.5f;
constexpr float kExpandArrowShowEndFraction = 1.0f;
// Range of the height of centerline above screen bottom that all apps should
// change opacity.
constexpr float kAllAppsOpacityStartPx = 8.0f;
constexpr float kAllAppsOpacityEndPx = 144.0f;
// The length of time we ignore scroll events on the AppsGridView after the
// AppListView transitions to FULLSCREEN_ALL_APPS.
constexpr base::TimeDelta kIgnoreScrollEventsDurationMs =
base::TimeDelta::FromMilliseconds(500);
// Returns the size of a tile view excluding its padding.
gfx::Size GetTileViewSize() {
if (features::IsFullscreenAppListEnabled())
return gfx::Size(kGridTileWidth, kGridTileHeight);
return gfx::Size(kPreferredTileWidth, kPreferredTileHeight);
}
// RowMoveAnimationDelegate is used when moving an item into a different row.
// Before running the animation, the item's layer is re-created and kept in
// the original position, then the item is moved to just before its target
// position and opacity set to 0. When the animation runs, this delegate moves
// the layer and fades it out while fading in the item at the same time.
class RowMoveAnimationDelegate : public gfx::AnimationDelegate {
public:
RowMoveAnimationDelegate(views::View* view,
ui::Layer* layer,
const gfx::Rect& layer_target)
: view_(view),
layer_(layer),
layer_start_(layer ? layer->bounds() : gfx::Rect()),
layer_target_(layer_target) {}
~RowMoveAnimationDelegate() override {}
// gfx::AnimationDelegate overrides:
void AnimationProgressed(const gfx::Animation* animation) override {
view_->layer()->SetOpacity(animation->GetCurrentValue());
view_->layer()->ScheduleDraw();
if (layer_) {
layer_->SetOpacity(1 - animation->GetCurrentValue());
layer_->SetBounds(
animation->CurrentValueBetween(layer_start_, layer_target_));
layer_->ScheduleDraw();
}
}
void AnimationEnded(const gfx::Animation* animation) override {
view_->layer()->SetOpacity(1.0f);
view_->SchedulePaint();
}
void AnimationCanceled(const gfx::Animation* animation) override {
view_->layer()->SetOpacity(1.0f);
view_->SchedulePaint();
}
private:
// The view that needs to be wrapped. Owned by views hierarchy.
views::View* view_;
std::unique_ptr<ui::Layer> layer_;
const gfx::Rect layer_start_;
const gfx::Rect layer_target_;
DISALLOW_COPY_AND_ASSIGN(RowMoveAnimationDelegate);
};
// ItemRemoveAnimationDelegate is used to show animation for removing an item.
// This happens when user drags an item into a folder. The dragged item will
// be removed from the original list after it is dropped into the folder.
class ItemRemoveAnimationDelegate : public gfx::AnimationDelegate {
public:
explicit ItemRemoveAnimationDelegate(views::View* view) : view_(view) {}
~ItemRemoveAnimationDelegate() override {}
// gfx::AnimationDelegate overrides:
void AnimationProgressed(const gfx::Animation* animation) override {
view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
view_->layer()->ScheduleDraw();
}
private:
std::unique_ptr<views::View> view_;
DISALLOW_COPY_AND_ASSIGN(ItemRemoveAnimationDelegate);
};
// ItemMoveAnimationDelegate observes when an item finishes animating when it is
// not moving between rows. This is to ensure an item is repainted for the
// "zoom out" case when releasing an item being dragged.
class ItemMoveAnimationDelegate : public gfx::AnimationDelegate {
public:
explicit ItemMoveAnimationDelegate(views::View* view) : view_(view) {}
void AnimationEnded(const gfx::Animation* animation) override {
view_->SchedulePaint();
}
void AnimationCanceled(const gfx::Animation* animation) override {
view_->SchedulePaint();
}
private:
views::View* view_;
DISALLOW_COPY_AND_ASSIGN(ItemMoveAnimationDelegate);
};
// Returns true if the |item| is a folder item.
bool IsFolderItem(AppListItem* item) {
return (item->GetItemType() == AppListFolderItem::kItemType);
}
bool IsOEMFolderItem(AppListItem* item) {
return IsFolderItem(item) &&
(static_cast<AppListFolderItem*>(item))->folder_type() ==
AppListFolderItem::FOLDER_TYPE_OEM;
}
class PaginationAnimationMetricsReporter : public ui::AnimationMetricsReporter {
public:
PaginationAnimationMetricsReporter() = default;
~PaginationAnimationMetricsReporter() override = default;
// ui::AnimationMetricsReporter:
void Report(int value) override {
UMA_HISTOGRAM_PERCENTAGE("Apps.PaginationTransition.AnimationSmoothness",
value);
}
private:
DISALLOW_COPY_AND_ASSIGN(PaginationAnimationMetricsReporter);
};
int GetCompositorActivatedFrameCount(ui::Layer* layer) {
const ui::Compositor* compositor = layer->GetCompositor();
return compositor ? compositor->activated_frame_count() : 0;
}
float GetCompositorRefreshRate(ui::Layer* layer) {
const ui::Compositor* compositor = layer->GetCompositor();
return compositor ? compositor->refresh_rate() : 60.0f;
}
int CalculateAnimationSmoothness(int actual_frames,
base::TimeDelta ideal_duration,
ui::Layer* layer) {
int smoothness = 100;
const int ideal_frames = ideal_duration.InMillisecondsF() /
base::Time::kMillisecondsPerSecond *
GetCompositorRefreshRate(layer);
if (ideal_frames > actual_frames)
smoothness = 100 * actual_frames / ideal_frames;
return smoothness;
}
} // namespace
// A layer delegate used for AppsGridView's mask layer, with top and bottom
// gradient fading out zones.
class AppsGridView::FadeoutLayerDelegate : public ui::LayerDelegate {
public:
FadeoutLayerDelegate() : layer_(ui::LAYER_TEXTURED) {
layer_.set_delegate(this);
layer_.SetFillsBoundsOpaquely(false);
}
~FadeoutLayerDelegate() override { layer_.set_delegate(nullptr); }
ui::Layer* layer() { return &layer_; }
private:
// ui::LayerDelegate overrides:
// TODO(warx): using a mask is expensive. It would be more efficient to avoid
// the mask for the central area and only use it for top/bottom areas.
void OnPaintLayer(const ui::PaintContext& context) override {
const gfx::Size size = layer()->size();
gfx::Rect top_rect(0, 0, size.width(), kFadeoutZoneHeight);
gfx::Rect bottom_rect(0, size.height() - kFadeoutZoneHeight, size.width(),
kFadeoutZoneHeight);
ui::PaintRecorder recorder(context, size);
gfx::Canvas* canvas = recorder.canvas();
// Clear the canvas.
canvas->DrawColor(SK_ColorBLACK, SkBlendMode::kSrc);
// Draw top gradient zone.
cc::PaintFlags flags;
flags.setBlendMode(SkBlendMode::kSrc);
flags.setAntiAlias(false);
flags.setShader(gfx::CreateGradientShader(
0, kFadeoutZoneHeight, SK_ColorTRANSPARENT, SK_ColorBLACK));
canvas->DrawRect(top_rect, flags);
// Draw bottom gradient zone.
flags.setShader(gfx::CreateGradientShader(
size.height() - kFadeoutZoneHeight, size.height(), SK_ColorBLACK,
SK_ColorTRANSPARENT));
canvas->DrawRect(bottom_rect, flags);
}
void OnDeviceScaleFactorChanged(float old_device_scale_factor,
float new_device_scale_factor) override {}
ui::Layer layer_;
DISALLOW_COPY_AND_ASSIGN(FadeoutLayerDelegate);
};
AppsGridView::AppsGridView(ContentsView* contents_view,
AppsGridViewFolderDelegate* folder_delegate)
: folder_delegate_(folder_delegate),
contents_view_(contents_view),
bounds_animator_(this),
is_fullscreen_app_list_enabled_(features::IsFullscreenAppListEnabled()),
page_flip_delay_in_ms_(is_fullscreen_app_list_enabled_
? kPageFlipDelayInMsFullscreen
: kPageFlipDelayInMs),
pagination_animation_metrics_reporter_(
std::make_unique<PaginationAnimationMetricsReporter>()),
pagination_animation_start_frame_number_(0) {
DCHECK(contents_view_);
SetPaintToLayer();
// Clip any icons that are outside the grid view's bounds. These icons would
// otherwise be visible to the user when the grid view is off screen.
layer()->SetMasksToBounds(true);
layer()->SetFillsBoundsOpaquely(false);
if (is_fullscreen_app_list_enabled_ && !folder_delegate_) {
suggestions_container_ =
new SuggestionsContainerView(contents_view_, &pagination_model_);
AddChildView(suggestions_container_);
UpdateSuggestions();
all_apps_indicator_ = new IndicatorChipView(
l10n_util::GetStringUTF16(IDS_ALL_APPS_INDICATOR));
AddChildView(all_apps_indicator_);
if (features::IsBackgroundBlurEnabled()) {
// TODO(newcomer): Improve implementation of the mask layer so we can
// enable it on all devices crbug.com/765292.
fadeout_layer_delegate_.reset(new FadeoutLayerDelegate);
layer()->SetMaskLayer(fadeout_layer_delegate_->layer());
}
expand_arrow_view_ =
new ExpandArrowView(contents_view_, contents_view_->app_list_view());
AddChildView(expand_arrow_view_);
}
pagination_model_.SetTransitionDurations(kPageTransitionDurationInMs,
kOverscrollPageTransitionDurationMs);
pagination_model_.AddObserver(this);
if (is_fullscreen_app_list_enabled_) {
page_switcher_view_ = new PageSwitcherVertical(&pagination_model_);
pagination_controller_.reset(new PaginationController(
&pagination_model_, PaginationController::SCROLL_AXIS_VERTICAL));
} else {
page_switcher_view_ = new PageSwitcherHorizontal(&pagination_model_);
pagination_controller_.reset(new PaginationController(
&pagination_model_, PaginationController::SCROLL_AXIS_HORIZONTAL));
}
AddChildView(page_switcher_view_);
}
AppsGridView::~AppsGridView() {
// Coming here |drag_view_| should already be canceled since otherwise the
// drag would disappear after the app list got animated away and closed,
// which would look odd.
DCHECK(!drag_view_);
if (drag_view_)
EndDrag(true);
if (model_)
model_->RemoveObserver(this);
pagination_model_.RemoveObserver(this);
if (item_list_)
item_list_->RemoveObserver(this);
// Make sure |page_switcher_view_| is deleted before |pagination_model_|.
view_model_.Clear();
RemoveAllChildViews(true);
}
void AppsGridView::SetLayout(int cols, int rows_per_page) {
cols_ = cols;
rows_per_page_ = rows_per_page;
if (!is_fullscreen_app_list_enabled_) {
SetBorder(
views::CreateEmptyBorder(0, kAppsGridPadding, 0, kAppsGridPadding));
}
}
// static
gfx::Size AppsGridView::GetTotalTileSize() {
static gfx::Size rect_size;
if (!rect_size.IsEmpty())
return rect_size;
gfx::Rect rect(GetTileViewSize());
rect.Inset(GetTilePadding());
rect_size = rect.size();
return rect_size;
}
// static
gfx::Insets AppsGridView::GetTilePadding() {
static gfx::Insets tile_padding;
static gfx::Insets tile_padding_full_screen;
// Full screen mode.
if (features::IsFullscreenAppListEnabled()) {
if (!tile_padding_full_screen.IsEmpty())
return tile_padding_full_screen;
tile_padding_full_screen =
gfx::Insets(-kTileVerticalPadding, -kTileHorizontalPadding,
-kTileVerticalPadding, -kTileHorizontalPadding);
return tile_padding_full_screen;
}
// Non full screen mode.
if (!tile_padding.IsEmpty()) {
return tile_padding;
}
tile_padding = gfx::Insets(-kTileTopPadding, -kTileLeftRightPadding,
-kTileBottomPadding, -kTileLeftRightPadding);
return tile_padding;
}
void AppsGridView::ResetForShowApps() {
UpdateSuggestions();
activated_folder_item_view_ = nullptr;
ClearDragState();
layer()->SetOpacity(1.0f);
SetVisible(true);
// Set all views to visible in case they weren't made visible again by an
// incomplete animation.
for (int i = 0; i < view_model_.view_size(); ++i) {
view_model_.view_at(i)->SetVisible(true);
}
CHECK_EQ(item_list_->item_count(),
static_cast<size_t>(view_model_.view_size()));
}
void AppsGridView::SetModel(AppListModel* model) {
if (model_)
model_->RemoveObserver(this);
model_ = model;
if (model_)
model_->AddObserver(this);
Update();
}
void AppsGridView::SetItemList(AppListItemList* item_list) {
if (item_list_)
item_list_->RemoveObserver(this);
item_list_ = item_list;
if (item_list_)
item_list_->AddObserver(this);
Update();
}
void AppsGridView::SetSelectedView(AppListItemView* view) {
if (IsSelectedView(view) || IsDraggedView(view))
return;
Index index = GetIndexOfView(view);
if (IsValidIndex(index))
SetSelectedItemByIndex(index);
}
void AppsGridView::ClearSelectedView(AppListItemView* view) {
if (view && IsSelectedView(view)) {
selected_view_->SchedulePaint();
selected_view_ = nullptr;
}
}
void AppsGridView::ClearAnySelectedView() {
if (selected_view_) {
selected_view_->SchedulePaint();
selected_view_ = nullptr;
}
if (suggestions_container_)
suggestions_container_->ClearSelectedIndex();
if (expand_arrow_view_)
expand_arrow_view_->SetSelected(false);
}
bool AppsGridView::IsSelectedView(const AppListItemView* view) const {
return selected_view_ == view;
}
views::View* AppsGridView::GetSelectedView() const {
if (selected_view_)
return selected_view_;
if (expand_arrow_view_ && expand_arrow_view_->selected())
return expand_arrow_view_;
if (suggestions_container_)
return suggestions_container_->GetSelectedView();
return nullptr;
}
void AppsGridView::InitiateDrag(AppListItemView* view,
Pointer pointer,
const gfx::Point& location,
const gfx::Point& root_location) {
DCHECK(view);
if (drag_view_ || pulsing_blocks_model_.view_size())
return;
drag_view_ = view;
drag_view_init_index_ = GetIndexOfView(drag_view_);
drag_view_offset_ = location;
drag_start_page_ = pagination_model_.selected_page();
reorder_placeholder_ = drag_view_init_index_;
ExtractDragLocation(root_location, &drag_start_grid_view_);
drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
}
void AppsGridView::StartDragAndDropHostDragAfterLongPress(Pointer pointer) {
TryStartDragAndDropHostDrag(pointer, drag_start_grid_view_);
}
void AppsGridView::TryStartDragAndDropHostDrag(
Pointer pointer,
const gfx::Point& grid_location) {
drag_pointer_ = pointer;
// Move the view to the front so that it appears on top of other views.
ReorderChildView(drag_view_, -1);
bounds_animator_.StopAnimatingView(drag_view_);
// Stopping the animation may have invalidated our drag view due to the
// view hierarchy changing.
if (!drag_view_)
return;
if (!dragging_for_reparent_item_)
StartDragAndDropHostDrag(grid_location);
}
bool AppsGridView::UpdateDragFromItem(Pointer pointer,
const ui::LocatedEvent& event) {
if (!drag_view_)
return false; // Drag canceled.
gfx::Point drag_point_in_grid_view;
ExtractDragLocation(event.root_location(), &drag_point_in_grid_view);
UpdateDrag(pointer, drag_point_in_grid_view);
if (!dragging())
return false;
// If a drag and drop host is provided, see if the drag operation needs to be
// forwarded.
gfx::Point location_in_screen = drag_point_in_grid_view;
views::View::ConvertPointToScreen(this, &location_in_screen);
DispatchDragEventToDragAndDropHost(location_in_screen);
if (drag_and_drop_host_) {
drag_and_drop_host_->UpdateDragIconProxyByLocation(
drag_view_->icon()->GetBoundsInScreen().origin());
}
return true;
}
void AppsGridView::UpdateDrag(Pointer pointer, const gfx::Point& point) {
if (folder_delegate_)
UpdateDragStateInsideFolder(pointer, point);
if (!drag_view_)
return; // Drag canceled.
gfx::Vector2d drag_vector(point - drag_start_grid_view_);
if (!dragging() && ExceededDragThreshold(drag_vector))
TryStartDragAndDropHostDrag(pointer, point);
if (drag_pointer_ != pointer)
return;
drag_view_->SetPosition(drag_view_start_ + drag_vector);
last_drag_point_ = point;
const Index last_reorder_drop_target = reorder_drop_target_;
const Index last_folder_drop_target = folder_drop_target_;
DropAttempt last_drop_attempt = drop_attempt_;
CalculateDropTarget();
MaybeStartPageFlipTimer(last_drag_point_);
gfx::Point page_switcher_point(last_drag_point_);
views::View::ConvertPointToTarget(this, page_switcher_view_,
&page_switcher_point);
page_switcher_view_->UpdateUIForDragPoint(page_switcher_point);
if (last_folder_drop_target != folder_drop_target_ ||
last_reorder_drop_target != reorder_drop_target_ ||
last_drop_attempt != drop_attempt_) {
if (drop_attempt_ == DROP_FOR_REORDER) {
folder_dropping_timer_.Stop();
reorder_timer_.Start(FROM_HERE,
base::TimeDelta::FromMilliseconds(kReorderDelay),
this, &AppsGridView::OnReorderTimer);
} else if (drop_attempt_ == DROP_FOR_FOLDER) {
reorder_timer_.Stop();
folder_dropping_timer_.Start(
FROM_HERE, base::TimeDelta::FromMilliseconds(kFolderDroppingDelay),
this, &AppsGridView::OnFolderDroppingTimer);
}
// Reset the previous drop target.
SetAsFolderDroppingTarget(last_folder_drop_target, false);
}
}
void AppsGridView::EndDrag(bool cancel) {
// EndDrag was called before if |drag_view_| is NULL.
if (!drag_view_)
return;
// Coming here a drag and drop was in progress.
bool landed_in_drag_and_drop_host = forward_events_to_drag_and_drop_host_;
if (forward_events_to_drag_and_drop_host_) {
DCHECK(!IsDraggingForReparentInRootLevelGridView());
forward_events_to_drag_and_drop_host_ = false;
drag_and_drop_host_->EndDrag(cancel);
if (IsDraggingForReparentInHiddenGridView()) {
folder_delegate_->DispatchEndDragEventForReparent(
true /* events_forwarded_to_drag_drop_host */,
cancel /* cancel_drag */);
}
} else {
if (IsDraggingForReparentInHiddenGridView()) {
// Forward the EndDrag event to the root level grid view.
folder_delegate_->DispatchEndDragEventForReparent(
false /* events_forwarded_to_drag_drop_host */,
cancel /* cancel_drag */);
EndDragForReparentInHiddenFolderGridView();
return;
}
if (IsDraggingForReparentInRootLevelGridView()) {
// An EndDrag can be received during a reparent via a model change. This
// is always a cancel and needs to be forwarded to the folder.
DCHECK(cancel);
contents_view_->app_list_main_view()->CancelDragInActiveFolder();
return;
}
if (!cancel && dragging()) {
// Regular drag ending path, ie, not for reparenting.
CalculateDropTarget();
if (EnableFolderDragDropUI() && drop_attempt_ == DROP_FOR_FOLDER &&
IsValidIndex(folder_drop_target_)) {
MoveItemToFolder(drag_view_, folder_drop_target_);
} else if (IsValidIndex(reorder_drop_target_)) {
MoveItemInModel(drag_view_, reorder_drop_target_);
}
}
}
if (drag_and_drop_host_) {
// If we had a drag and drop proxy icon, we delete it and make the real
// item visible again.
drag_and_drop_host_->DestroyDragIconProxy();
// Issue 439055: MoveItemToFolder() can sometimes delete |drag_view_|
if (drag_view_) {
if (landed_in_drag_and_drop_host) {
// Move the item directly to the target location, avoiding the
// "zip back" animation if the user was pinning it to the shelf.
int i = reorder_drop_target_.slot;
gfx::Rect bounds = view_model_.ideal_bounds(i);
drag_view_->SetBoundsRect(bounds);
}
// Fade in slowly if it landed in the shelf.
SetViewHidden(drag_view_, false /* show */,
!landed_in_drag_and_drop_host /* animate */);
}
}
SetAsFolderDroppingTarget(folder_drop_target_, false);
ClearDragState();
AnimateToIdealBounds();
StopPageFlipTimer();
// If user releases mouse inside a folder's grid view, burst the folder
// container ink bubble.
if (folder_delegate_ && !IsDraggingForReparentInHiddenGridView())
folder_delegate_->UpdateFolderViewBackground(false);
}
void AppsGridView::StopPageFlipTimer() {
page_flip_timer_.Stop();
page_flip_target_ = -1;
}
AppListItemView* AppsGridView::GetItemViewAt(int index) const {
return view_model_.view_at(index);
}
void AppsGridView::SetTopItemViewsVisible(bool visible) {
int top_item_count =
std::min(static_cast<int>(FolderImage::kNumFolderTopItems),
view_model_.view_size());
for (int i = 0; i < top_item_count; ++i)
GetItemViewAt(i)->icon()->SetVisible(visible);
}
void AppsGridView::ScheduleShowHideAnimation(bool show) {
// Stop any previous animation.
layer()->GetAnimator()->StopAnimating();
// Set initial state.
SetVisible(true);
layer()->SetOpacity(show ? 0.0f : 1.0f);
ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
animation.AddObserver(this);
animation.SetTweenType(show ? kFolderFadeInTweenType
: kFolderFadeOutTweenType);
animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
show ? kFolderTransitionInDurationMs : kFolderTransitionOutDurationMs));
layer()->SetOpacity(show ? 1.0f : 0.0f);
}
void AppsGridView::InitiateDragFromReparentItemInRootLevelGridView(
AppListItemView* original_drag_view,
const gfx::Rect& drag_view_rect,
const gfx::Point& drag_point,
bool has_native_drag) {
DCHECK(original_drag_view && !drag_view_);
DCHECK(!dragging_for_reparent_item_);
// Since the item is new, its placeholder is conceptually at the back of the
// entire apps grid.
reorder_placeholder_ = GetLastViewIndex();
// Create a new AppListItemView to duplicate the original_drag_view in the
// folder's grid view.
AppListItemView* view = new AppListItemView(
this, original_drag_view->item(),
contents_view_->app_list_main_view()->view_delegate());
AddChildView(view);
drag_view_ = view;
drag_view_->SetPaintToLayer();
drag_view_->layer()->SetFillsBoundsOpaquely(false);
drag_view_->SetBoundsRect(drag_view_rect);
drag_view_->SetDragUIState(); // Hide the title of the drag_view_.
// Hide the drag_view_ for drag icon proxy when a native drag is responsible
// for showing the icon.
if (has_native_drag)
SetViewHidden(drag_view_, true /* hide */, true /* no animate */);
// Add drag_view_ to the end of the view_model_.
view_model_.Add(drag_view_, view_model_.view_size());
drag_start_page_ = pagination_model_.selected_page();
drag_start_grid_view_ = drag_point;
drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
// Set the flag in root level grid view.
dragging_for_reparent_item_ = true;
}
void AppsGridView::UpdateDragFromReparentItem(Pointer pointer,
const gfx::Point& drag_point) {
// Note that if a cancel ocurrs while reparenting, the |drag_view_| in both
// root and folder grid views is cleared, so the check in UpdateDragFromItem()
// for |drag_view_| being NULL (in the folder grid) is sufficient.
DCHECK(drag_view_);
DCHECK(IsDraggingForReparentInRootLevelGridView());
UpdateDrag(pointer, drag_point);
}
bool AppsGridView::IsDraggedView(const AppListItemView* view) const {
return drag_view_ == view;
}
void AppsGridView::ClearDragState() {
drop_attempt_ = DROP_FOR_NONE;
drag_pointer_ = NONE;
reorder_drop_target_ = Index();
folder_drop_target_ = Index();
reorder_placeholder_ = Index();
drag_start_grid_view_ = gfx::Point();
drag_start_page_ = -1;
drag_view_offset_ = gfx::Point();
if (drag_view_) {
drag_view_->OnDragEnded();
if (IsDraggingForReparentInRootLevelGridView()) {
const int drag_view_index = view_model_.GetIndexOfView(drag_view_);
CHECK_EQ(view_model_.view_size() - 1, drag_view_index);
DeleteItemViewAtIndex(drag_view_index);
}
}
drag_view_ = nullptr;
dragging_for_reparent_item_ = false;
}
void AppsGridView::SetDragViewVisible(bool visible) {
DCHECK(drag_view_);
SetViewHidden(drag_view_, !visible, true);
}
void AppsGridView::SetDragAndDropHostOfCurrentAppList(
ApplicationDragAndDropHost* drag_and_drop_host) {
drag_and_drop_host_ = drag_and_drop_host;
}
bool AppsGridView::IsAnimatingView(AppListItemView* view) {
return bounds_animator_.IsAnimating(view);
}
gfx::Size AppsGridView::CalculatePreferredSize() const {
if (is_fullscreen_app_list_enabled_) {
gfx::Size size =
gfx::Size(kAppsGridPreferredWidth, kAppsGridPreferredHeight);
// Add padding to both side of the apps grid to keep it horizontally
// centered since we place page switcher on the right side.
size.Enlarge(kAppsGridLeftRightPadding * 2, 0);
return size;
}
gfx::Size size = GetTileGridSize();
const gfx::Insets insets(GetInsets());
// If we are in a folder, ignore the page switcher for height calculations.
int page_switcher_height =
folder_delegate_ ? 0 : page_switcher_view_->GetPreferredSize().height();
size.Enlarge(insets.width(), insets.height() + page_switcher_height);
return size;
}
bool AppsGridView::GetDropFormats(
int* formats,
std::set<ui::Clipboard::FormatType>* format_types) {
// TODO(koz): Only accept a specific drag type for app shortcuts.
*formats = OSExchangeData::FILE_NAME;
return true;
}
bool AppsGridView::CanDrop(const OSExchangeData& data) {
return true;
}
int AppsGridView::OnDragUpdated(const ui::DropTargetEvent& event) {
return ui::DragDropTypes::DRAG_MOVE;
}
const char* AppsGridView::GetClassName() const {
return "AppsGridView";
}
void AppsGridView::Layout() {
if (bounds_animator_.IsAnimating())
bounds_animator_.Cancel();
gfx::Rect rect(GetContentsBounds());
if (rect.IsEmpty())
return;
if (is_fullscreen_app_list_enabled_) {
if (fadeout_layer_delegate_)
fadeout_layer_delegate_->layer()->SetBounds(layer()->bounds());
rect.Inset(0, kSearchBoxBottomPadding, 0, 0);
}
gfx::Rect indicator_rect(rect);
gfx::Rect arrow_rect(rect);
if (suggestions_container_) {
gfx::Rect suggestions_rect(rect);
suggestions_rect.set_height(
suggestions_container_->GetHeightForWidth(suggestions_rect.width()));
suggestions_rect.Offset((suggestions_rect.width() - kGridTileWidth) / 2 -
(kGridTileWidth + kGridTileSpacing) * 2,
0);
suggestions_rect.Offset(CalculateTransitionOffset(0));
suggestions_container_->SetBoundsRect(suggestions_rect);
indicator_rect.Inset(0,
suggestions_container_->GetPreferredSize().height() +
kSuggestionsAllAppsIndicatorPadding,
0, 0);
arrow_rect.Inset(0,
suggestions_container_->GetPreferredSize().height() +
kExpandArrowTopPadding,
0, 0);
}
if (all_apps_indicator_) {
gfx::Size indicator_size;
indicator_size = all_apps_indicator_->GetPreferredSize();
indicator_rect.Inset((indicator_rect.width() - indicator_size.width()) / 2,
0);
indicator_rect.Offset(CalculateTransitionOffset(0));
all_apps_indicator_->SetBoundsRect(indicator_rect);
}
if (expand_arrow_view_) {
int left_right_padding =
(arrow_rect.width() - expand_arrow_view_->GetPreferredSize().width()) /
2;
arrow_rect.Inset(left_right_padding, 0);
arrow_rect.set_height(expand_arrow_view_->GetPreferredSize().height());
expand_arrow_view_->SetBoundsRect(arrow_rect);
}
CalculateIdealBounds();
for (int i = 0; i < view_model_.view_size(); ++i) {
AppListItemView* view = GetItemViewAt(i);
if (view != drag_view_)
view->SetBoundsRect(view_model_.ideal_bounds(i));
}
views::ViewModelUtils::SetViewBoundsToIdealBounds(pulsing_blocks_model_);
if (is_fullscreen_app_list_enabled_) {
const int page_switcher_width =
page_switcher_view_->GetPreferredSize().width();
rect.set_x(rect.right() - page_switcher_width);
rect.set_width(page_switcher_width);
} else {
const int page_switcher_height =
page_switcher_view_->GetPreferredSize().height();
rect.set_y(rect.bottom() - page_switcher_height);
rect.set_height(page_switcher_height);
}
page_switcher_view_->SetBoundsRect(rect);
}
void AppsGridView::UpdateControlVisibility(AppListViewState app_list_state,
bool is_in_drag) {
if (!is_fullscreen_app_list_enabled_)
return;
const bool fullscreen_apps_in_drag =
app_list_state == AppListViewState::FULLSCREEN_ALL_APPS || is_in_drag;
if (all_apps_indicator_)
all_apps_indicator_->SetVisible(fullscreen_apps_in_drag);
if (expand_arrow_view_) {
expand_arrow_view_->SetVisible(
app_list_state == AppListViewState::PEEKING ? true : false);
}
for (int i = 0; i < view_model_.view_size(); ++i) {
AppListItemView* view = GetItemViewAt(i);
view->SetVisible(fullscreen_apps_in_drag);
}
page_switcher_view_->SetVisible(fullscreen_apps_in_drag);
}
bool AppsGridView::OnKeyPressed(const ui::KeyEvent& event) {
// Let the FocusManager handle Left/Right keys.
if (!CanProcessUpDownKeyTraversal(event))
return false;
const AppListViewState state =
contents_view_->app_list_view()->app_list_state();
const bool arrow_up = event.key_code() == ui::VKEY_UP;
if (state == AppListViewState::PEEKING)
return HandleFocusMovementInPeekingState(arrow_up);
DCHECK(state == AppListViewState::FULLSCREEN_ALL_APPS);
return HandleFocusMovementInFullscreenAllAppsState(arrow_up);
}
void AppsGridView::ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) {
if (!details.is_add && details.parent == this) {
// The view being delete should not have reference in |view_model_|.
CHECK_EQ(-1, view_model_.GetIndexOfView(details.child));
if (selected_view_ == details.child)
selected_view_ = nullptr;
if (activated_folder_item_view_ == details.child)
activated_folder_item_view_ = nullptr;
if (drag_view_ == details.child)
EndDrag(true);
bounds_animator_.StopAnimatingView(details.child);
}
}
void AppsGridView::OnGestureEvent(ui::GestureEvent* event) {
// Bail on STATE_START or no apps page to make PaginationModel happy.
if (contents_view_->GetActiveState() == AppListModel::STATE_START ||
pagination_model_.total_pages() <= 0) {
return;
}
if (!contents_view_->app_list_view()->is_in_drag() &&
pagination_controller_->OnGestureEvent(*event, GetContentsBounds())) {
event->SetHandled();
} else {
event->ConvertLocationToTarget(
static_cast<View*>(this),
static_cast<View*>(contents_view_->app_list_view()));
contents_view_->app_list_view()->OnGestureEvent(event);
}
}
void AppsGridView::Update() {
DCHECK(!selected_view_ && !drag_view_);
view_model_.Clear();
if (!item_list_ || !item_list_->item_count())
return;
for (size_t i = 0; i < item_list_->item_count(); ++i) {
AppListItemView* view = CreateViewForItemAtIndex(i);
view_model_.Add(view, i);
AddChildView(view);
}
UpdatePaging();
UpdatePulsingBlockViews();
Layout();
SchedulePaint();
}
void AppsGridView::UpdateSuggestions() {
if (!suggestions_container_)
return;
suggestions_container_->SetResults(contents_view_->app_list_main_view()
->view_delegate()
->GetSearchModel()
->results());
}
int AppsGridView::TilesPerPage(int page) const {
if (is_fullscreen_app_list_enabled_ && page == 0)
return cols_ * (rows_per_page_ - 1);
return cols_ * rows_per_page_;
}
int AppsGridView::LastIndexOfPage(int page) const {
return TilesPerPage(page) - 1;
}
void AppsGridView::UpdatePaging() {
if (!view_model_.view_size() || !TilesPerPage(0)) {
pagination_model_.SetTotalPages(0);
return;
}
int total_pages = 0;
if (view_model_.view_size() <= TilesPerPage(0)) {
total_pages = 1;
} else {
total_pages =
(view_model_.view_size() - TilesPerPage(0) - 1) / TilesPerPage(1) + 2;
}
pagination_model_.SetTotalPages(total_pages);
}
void AppsGridView::UpdatePulsingBlockViews() {
const int existing_items = item_list_ ? item_list_->item_count() : 0;
int current_page = pagination_model_.selected_page();
const int available_slots =
TilesPerPage(current_page) - existing_items % TilesPerPage(current_page);
const int desired =
model_->status() == AppListModel::STATUS_SYNCING ? available_slots : 0;
if (pulsing_blocks_model_.view_size() == desired)
return;
while (pulsing_blocks_model_.view_size() > desired) {
PulsingBlockView* view = pulsing_blocks_model_.view_at(0);
pulsing_blocks_model_.Remove(0);
delete view;
}
while (pulsing_blocks_model_.view_size() < desired) {
PulsingBlockView* view = new PulsingBlockView(GetTotalTileSize(), true);
pulsing_blocks_model_.Add(view, 0);
AddChildView(view);
}
}
AppListItemView* AppsGridView::CreateViewForItemAtIndex(size_t index) {
// The drag_view_ might be pending for deletion, therefore view_model_
// may have one more item than item_list_.
DCHECK_LE(index, item_list_->item_count());
AppListItemView* view = new AppListItemView(
this, item_list_->item_at(index),
contents_view_->app_list_main_view()->view_delegate());
view->SetPaintToLayer();
view->layer()->SetFillsBoundsOpaquely(false);
return view;
}
bool AppsGridView::HandleScroll(int offset, ui::EventType type) {
if (is_ignoring_scroll_events_)
return false;
// Bail on STATE_START or no apps page to make PaginationModel happy.
if (contents_view_->GetActiveState() == AppListModel::STATE_START ||
pagination_model_.total_pages() <= 0) {
return false;
}
const gfx::Vector2dF scroll_offset_vector(0, offset);
return pagination_controller_->OnScroll(
gfx::ToFlooredVector2d(scroll_offset_vector), type);
}
AppsGridView::Index AppsGridView::GetIndexFromModelIndex(
int model_index) const {
if (model_index < TilesPerPage(0))
return Index(0, model_index);
return Index(1 + (model_index - TilesPerPage(0)) / TilesPerPage(1),
(model_index - TilesPerPage(0)) % TilesPerPage(1));
}
int AppsGridView::GetModelIndexFromIndex(const Index& index) const {
if (index.page == 0)
return index.slot;
return TilesPerPage(0) + (index.page - 1) * TilesPerPage(1) + index.slot;
}
void AppsGridView::EnsureViewVisible(const Index& index) {
if (pagination_model_.has_transition())
return;
if (IsValidIndex(index))
pagination_model_.SelectPage(index.page, false);
}
void AppsGridView::SetSelectedItemByIndex(const Index& index) {
if (GetIndexOfView(selected_view_) == index)
return;
AppListItemView* new_selection = GetViewAtIndex(index);
if (!new_selection)
return; // Keep current selection.
if (selected_view_)
selected_view_->SchedulePaint();
EnsureViewVisible(index);
selected_view_ = new_selection;
selected_view_->SetTitleSubpixelAA();
selected_view_->SchedulePaint();
selected_view_->NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION, true);
}
bool AppsGridView::IsValidIndex(const Index& index) const {
return index.page >= 0 && index.page < pagination_model_.total_pages() &&
index.slot >= 0 && index.slot < TilesPerPage(index.page) &&
GetModelIndexFromIndex(index) < view_model_.view_size();
}
AppsGridView::Index AppsGridView::GetIndexOfView(
const AppListItemView* view) const {
const int model_index = view_model_.GetIndexOfView(view);
if (model_index == -1)
return Index();
return GetIndexFromModelIndex(model_index);
}
AppListItemView* AppsGridView::GetViewAtIndex(const Index& index) const {
if (!IsValidIndex(index))
return nullptr;
const int model_index = GetModelIndexFromIndex(index);
return GetItemViewAt(model_index);
}
AppsGridView::Index AppsGridView::GetLastViewIndex() const {
DCHECK_LT(0, view_model_.view_size());
int view_index = view_model_.view_size() - 1;
return GetIndexFromModelIndex(view_index);
}
void AppsGridView::MoveSelected(int page_delta,
int slot_x_delta,
int slot_y_delta) {
if (expand_arrow_view_ && expand_arrow_view_->selected() &&
HandleExpandArrowMove(page_delta, slot_x_delta, slot_y_delta)) {
return;
}
if (!selected_view_) {
// If fullscreen app list is enabled and we are on the first page, moving
// selected should consider suggested apps tiles before all apps tiles.
int current_page = pagination_model_.selected_page();
if (!suggestions_container_ || current_page != 0)
return SetSelectedItemByIndex(Index(current_page, 0));
if (HandleSuggestionsMove(page_delta, slot_x_delta, slot_y_delta))
return;
}
const Index& selected = GetIndexOfView(selected_view_);
int target_slot = selected.slot + slot_x_delta + slot_y_delta * cols_;
if (!is_fullscreen_app_list_enabled_) {
if (selected.slot % cols_ == 0 && slot_x_delta == -1) {
if (selected.page > 0) {
page_delta = -1;
target_slot = selected.slot + cols_ - 1;
} else {
target_slot = selected.slot;
}
}
if (selected.slot % cols_ == cols_ - 1 && slot_x_delta == 1) {
if (selected.page < pagination_model_.total_pages() - 1) {
page_delta = 1;
target_slot = selected.slot - cols_ + 1;
} else {
target_slot = selected.slot;
}
}
} else {
// Moving left from the first slot of all apps tiles should move focus to
// the last slot of previous page or last tile of suggested apps.
if (selected.slot == 0 && slot_x_delta == -1) {
if (selected.page == 0) {
ClearSelectedView(selected_view_);
if (!suggestions_container_)
return;
suggestions_container_->SetSelectedIndex(
suggestions_container_->num_results() - 1);
return;
} else {
page_delta = -1;
target_slot = LastIndexOfPage(selected.page + page_delta);
}
}
// Moving right from last slot should flip to next page and focus on the
// first tile.
if (selected.slot == LastIndexOfPage(selected.page) && slot_x_delta == 1) {
page_delta = 1;
target_slot = 0;
}
// Moving up from the first row of all apps tiles should move focus to the
// last row of previous page or suggested apps.
if (selected.slot / cols_ == 0 && slot_y_delta == -1) {
if (selected.page == 0) {
ClearSelectedView(selected_view_);
if (!suggestions_container_)
return;
const int max_suggestion_index =
suggestions_container_->num_results() - 1;
int selected_index = std::min(max_suggestion_index, selected.slot);
suggestions_container_->SetSelectedIndex(selected_index);
return;
} else {
page_delta = -1;
target_slot = LastIndexOfPage(selected.page + page_delta) -
(cols_ - 1 - selected.slot);
}
}
// Moving down from the last row of all apps tiles should move focus to the
// first row of next page if it exists.
if (LastIndexOfPage(selected.page) - selected.slot < cols_ &&
slot_y_delta == 1) {
if (selected.page < pagination_model_.total_pages() - 1) {
page_delta = 1;
target_slot =
(cols_ - 1) - (LastIndexOfPage(selected.page) - selected.slot);
} else {
target_slot = selected.slot;
}
}
}
// Clamp the target slot to the last item if we are moving in or to the last
// page but our target slot is past the end of the item list.
if (selected.page + page_delta == pagination_model_.total_pages() - 1) {
int last_item_slot =
GetIndexFromModelIndex(view_model_.view_size() - 1).slot;
if (last_item_slot < target_slot) {
target_slot = last_item_slot;
}
}
int target_page = std::min(pagination_model_.total_pages() - 1,
std::max(selected.page + page_delta, 0));
SetSelectedItemByIndex(Index(target_page, target_slot));
}
bool AppsGridView::HandleSuggestionsMove(int page_delta,
int slot_x_delta,
int slot_y_delta) {
DCHECK(suggestions_container_);
DCHECK(expand_arrow_view_);
if (suggestions_container_->selected_index() == -1) {
suggestions_container_->SetSelectedIndex(0);
return true;
}
if (page_delta == -1 || slot_y_delta == -1)
return true;
if (slot_x_delta != 0) {
int new_index = suggestions_container_->selected_index() + slot_x_delta;
if (new_index == suggestions_container_->num_results()) {
suggestions_container_->ClearSelectedIndex();
if (contents_view_->GetActiveState() == AppListModel::STATE_START) {
// In state start, moving right out of |suggestions_container_| should
// give selection to the expand arrow.
expand_arrow_view_->SetSelected(true);
} else {
DCHECK(contents_view_->GetActiveState() == AppListModel::STATE_APPS);
// In state apps, moving right out of |suggestions_container_| should
// give selection to the first tile of all apps.
SetSelectedItemByIndex(Index(0, 0));
}
} else if (suggestions_container_->IsValidSelectionIndex(new_index)) {
suggestions_container_->SetSelectedIndex(new_index);
}
return true;
}
if (slot_y_delta == 1) {
if (contents_view_->GetActiveState() == AppListModel::STATE_START) {
// In state start, moving down from |suggestions_container_| should give
// selection to the expand arrow.
expand_arrow_view_->SetSelected(true);
} else {
DCHECK(contents_view_->GetActiveState() == AppListModel::STATE_APPS);
// In state apps, moving down from |suggestions_container_| should give
// selection to the first row of all apps.
SetSelectedItemByIndex(
Index(0, suggestions_container_->selected_index()));
}
suggestions_container_->ClearSelectedIndex();
return true;
}
// A page flip to next page from |suggestions_container_| should focus to
// the first tile of next page.
if (page_delta == 1) {
SetSelectedItemByIndex(Index(page_delta, 0));
suggestions_container_->ClearSelectedIndex();
return true;
}
return false;
}
bool AppsGridView::HandleExpandArrowMove(int page_delta,
int slot_x_delta,
int slot_y_delta) {
DCHECK(suggestions_container_);
DCHECK(expand_arrow_view_);
DCHECK(contents_view_->GetActiveState() == AppListModel::STATE_START);
if (page_delta != 0 || slot_x_delta == 1 || slot_y_delta == 1 ||
(slot_x_delta == 0 && slot_y_delta == 0)) {
return true;
}
if (slot_x_delta == -1 || slot_y_delta == -1) {
// Move focus to the last app in ||suggestions_container|.
expand_arrow_view_->SetSelected(false);
suggestions_container_->SetSelectedIndex(
suggestions_container_->num_results() - 1);
return true;
}
return false;
}
const gfx::Vector2d AppsGridView::CalculateTransitionOffset(
int page_of_view) const {
gfx::Size grid_size = GetTileGridSize();
// If there is a transition, calculates offset for current and target page.
const int current_page = pagination_model_.selected_page();
const PaginationModel::Transition& transition =
pagination_model_.transition();
const bool is_valid = pagination_model_.is_valid_page(transition.target_page);
// Transition to previous page means negative offset.
const int dir = transition.target_page > current_page ? -1 : 1;
int x_offset = 0;
int y_offset = 0;
if (pagination_controller_->scroll_axis() ==
PaginationController::SCROLL_AXIS_HORIZONTAL) {
// Page size including padding pixels. A tile.x + page_width means the same
// tile slot in the next page.
const int page_width = grid_size.width() + kPagePadding;
if (page_of_view < current_page)
x_offset = -page_width;
else if (page_of_view > current_page)
x_offset = page_width;
if (is_valid) {
if (page_of_view == current_page ||
page_of_view == transition.target_page) {
x_offset += transition.progress * page_width * dir;
}
}
} else {
const int page_height = grid_size.height();
if (page_of_view < current_page)
y_offset = -page_height;
else if (page_of_view > current_page)
y_offset = page_height;
if (is_valid) {
if (page_of_view == current_page ||
page_of_view == transition.target_page) {
y_offset += transition.progress * page_height * dir;
}
}
// Adjust pages with bottom 56px spaces to have 48px page break space, but
// do not over adjust for ideal offset.
if (page_of_view > current_page && current_page >= 1)
y_offset = std::max(y_offset - kPageBreakSpaceAdjustment, 0);
else if (page_of_view < current_page && page_of_view >= 1)
y_offset = std::min(y_offset + kPageBreakSpaceAdjustment, 0);
}
return gfx::Vector2d(x_offset, y_offset);
}
void AppsGridView::CalculateIdealBounds() {
const int total_views =
view_model_.view_size() + pulsing_blocks_model_.view_size();
int slot_index = 0;
for (int i = 0; i < total_views; ++i) {
if (i < view_model_.view_size() && view_model_.view_at(i) == drag_view_)
continue;
Index view_index = GetIndexFromModelIndex(slot_index);
// Leaves a blank space in the grid for the current reorder placeholder.
if (reorder_placeholder_ == view_index) {
++slot_index;
view_index = GetIndexFromModelIndex(slot_index);
}
gfx::Rect tile_slot = GetExpectedTileBounds(view_index);
tile_slot.Offset(CalculateTransitionOffset(view_index.page));
if (i < view_model_.view_size()) {
view_model_.set_ideal_bounds(i, tile_slot);
} else {
pulsing_blocks_model_.set_ideal_bounds(i - view_model_.view_size(),
tile_slot);
}
++slot_index;
}
}
void AppsGridView::AnimateToIdealBounds() {
const gfx::Rect visible_bounds(GetVisibleBounds());
CalculateIdealBounds();
for (int i = 0; i < view_model_.view_size(); ++i) {
AppListItemView* view = GetItemViewAt(i);
if (view == drag_view_)
continue;
const gfx::Rect& target = view_model_.ideal_bounds(i);
if (bounds_animator_.GetTargetBounds(view) == target)
continue;
const gfx::Rect& current = view->bounds();
const bool current_visible = visible_bounds.Intersects(current);
const bool target_visible = visible_bounds.Intersects(target);
const bool visible = current_visible || target_visible;
const int y_diff = target.y() - current.y();
if (visible && y_diff && y_diff % GetTotalTileSize().height() == 0) {
AnimationBetweenRows(view, current_visible, current, target_visible,
target);
} else if (visible || bounds_animator_.IsAnimating(view)) {
bounds_animator_.AnimateViewTo(view, target);
bounds_animator_.SetAnimationDelegate(
view, std::unique_ptr<gfx::AnimationDelegate>(
new ItemMoveAnimationDelegate(view)));
} else {
view->SetBoundsRect(target);
}
}
}
void AppsGridView::AnimationBetweenRows(AppListItemView* view,
bool animate_current,
const gfx::Rect& current,
bool animate_target,
const gfx::Rect& target) {
// Determine page of |current| and |target|. -1 means in the left invisible
// page, 0 is the center visible page and 1 means in the right invisible page.
const int current_page =
current.x() < 0 ? -1 : current.x() >= width() ? 1 : 0;
const int target_page = target.x() < 0 ? -1 : target.x() >= width() ? 1 : 0;
const int dir = current_page < target_page || (current_page == target_page &&
current.y() < target.y())
? 1
: -1;
std::unique_ptr<ui::Layer> layer;
if (animate_current) {
layer = view->RecreateLayer();
layer->SuppressPaint();
view->layer()->SetFillsBoundsOpaquely(false);
view->layer()->SetOpacity(0.f);
}
const gfx::Size total_tile_size = GetTotalTileSize();
gfx::Rect current_out(current);
current_out.Offset(dir * total_tile_size.width(), 0);
gfx::Rect target_in(target);
if (animate_target)
target_in.Offset(-dir * total_tile_size.width(), 0);
view->SetBoundsRect(target_in);
bounds_animator_.AnimateViewTo(view, target);
bounds_animator_.SetAnimationDelegate(
view,
std::unique_ptr<gfx::AnimationDelegate>(
new RowMoveAnimationDelegate(view, layer.release(), current_out)));
}
void AppsGridView::ExtractDragLocation(const gfx::Point& root_location,
gfx::Point* drag_point) {
// Use root location of |event| instead of location in |drag_view_|'s
// coordinates because |drag_view_| has a scale transform and location
// could have integer round error and causes jitter.
*drag_point = root_location;
DCHECK(GetWidget());
aura::Window::ConvertPointToTarget(
GetWidget()->GetNativeWindow()->GetRootWindow(),
GetWidget()->GetNativeWindow(), drag_point);
views::View::ConvertPointFromWidget(this, drag_point);
// Ensure that |drag_point| is correct if RTL.
drag_point->set_x(GetMirroredXInView(drag_point->x()));
}
void AppsGridView::CalculateDropTarget() {
DCHECK(drag_view_);
gfx::Point point = drag_view_->icon()->bounds().CenterPoint();
views::View::ConvertPointToTarget(drag_view_, this, &point);
// Ensure that the drop target location is correct if RTL.
point.set_x(GetMirroredXInView(point.x()));
if (!IsPointWithinDragBuffer(point)) {
// Reset the reorder target to the original position if the cursor is
// outside the drag buffer.
if (IsDraggingForReparentInRootLevelGridView()) {
drop_attempt_ = DROP_FOR_NONE;
return;
}
reorder_drop_target_ = drag_view_init_index_;
drop_attempt_ = DROP_FOR_REORDER;
return;
}
if (EnableFolderDragDropUI() &&
CalculateFolderDropTarget(point, &folder_drop_target_)) {
drop_attempt_ = DROP_FOR_FOLDER;
return;
}
drop_attempt_ = DROP_FOR_REORDER;
CalculateReorderDropTarget(point, &reorder_drop_target_);
}
bool AppsGridView::CalculateFolderDropTarget(const gfx::Point& point,
Index* drop_target) const {
// Folders can't be dropped into other folders.
if (IsFolderItem(drag_view_->item()))
return false;
// A folder drop shouldn't happen on the reorder placeholder since that would
// be merging an item with itself.
Index nearest_tile_index(GetNearestTileIndexForPoint(point));
if (!IsValidIndex(nearest_tile_index) ||
nearest_tile_index == reorder_placeholder_) {
return false;
}
int distance_to_tile_center =
(point - GetExpectedTileBounds(nearest_tile_index).CenterPoint())
.Length();
if (distance_to_tile_center > kFolderDroppingCircleRadius)
return false;
AppListItemView* target_view =
GetViewDisplayedAtSlotOnCurrentPage(nearest_tile_index.slot);
if (!target_view)
return false;
AppListItem* target_item = target_view->item();
// Items can only be dropped into non-folders (which have no children) or
// folders that have fewer than the max allowed items.
// The OEM folder does not allow drag/drop of other items into it.
if (target_item->ChildItemCount() >= kMaxFolderItems ||
IsOEMFolderItem(target_item)) {
return false;
}
*drop_target = nearest_tile_index;
DCHECK(IsValidIndex(*drop_target));
return true;
}
void AppsGridView::CalculateReorderDropTarget(const gfx::Point& point,
Index* drop_target) const {
gfx::Rect bounds = GetContentsBounds();
Index grid_index = GetNearestTileIndexForPoint(point);
gfx::Point reorder_placeholder_center =
GetExpectedTileBounds(reorder_placeholder_).CenterPoint();
int x_offset_direction = 0;
if (grid_index == reorder_placeholder_) {
x_offset_direction = reorder_placeholder_center.x() <= point.x() ? -1 : 1;
} else {
x_offset_direction = reorder_placeholder_ < grid_index ? -1 : 1;
}
const gfx::Size total_tile_size = GetTotalTileSize();
int row = grid_index.slot / cols_;
// Offset the target column based on the direction of the target. This will
// result in earlier targets getting their reorder zone shifted backwards
// and later targets getting their reorder zones shifted forwards.
//
// This makes eordering feel like the user is slotting items into the spaces
// between apps.
int x_offset = x_offset_direction *
(total_tile_size.width() - kFolderDroppingCircleRadius) / 2;
int col = (point.x() - bounds.x() + x_offset) / total_tile_size.width();
col = base::ClampToRange(col, 0, cols_ - 1);
*drop_target =
std::min(Index(pagination_model_.selected_page(), row * cols_ + col),
GetLastViewIndex());
DCHECK(IsValidIndex(*drop_target));
}
void AppsGridView::OnReorderTimer() {
if (drop_attempt_ == DROP_FOR_REORDER) {
reorder_placeholder_ = reorder_drop_target_;
AnimateToIdealBounds();
}
}
void AppsGridView::OnFolderItemReparentTimer() {
DCHECK(folder_delegate_);
if (drag_out_of_folder_container_ && drag_view_) {
bool has_native_drag = drag_and_drop_host_ != nullptr;
folder_delegate_->ReparentItem(drag_view_, last_drag_point_,
has_native_drag);
// Set the flag in the folder's grid view.
dragging_for_reparent_item_ = true;
// Do not observe any data change since it is going to be hidden.
item_list_->RemoveObserver(this);
item_list_ = nullptr;
}
}
void AppsGridView::OnFolderDroppingTimer() {
if (drop_attempt_ == DROP_FOR_FOLDER)
SetAsFolderDroppingTarget(folder_drop_target_, true);
}
void AppsGridView::UpdateDragStateInsideFolder(Pointer pointer,
const gfx::Point& drag_point) {
if (IsUnderOEMFolder())
return;
if (IsDraggingForReparentInHiddenGridView()) {
// Dispatch drag event to root level grid view for re-parenting folder
// folder item purpose.
DispatchDragEventForReparent(pointer, drag_point);
return;
}
// Regular drag and drop in a folder's grid view.
folder_delegate_->UpdateFolderViewBackground(true);
// Calculate if the drag_view_ is dragged out of the folder's container
// ink bubble.
gfx::Rect bounds_to_folder_view = ConvertRectToParent(drag_view_->bounds());
gfx::Point pt = bounds_to_folder_view.CenterPoint();
bool is_item_dragged_out_of_folder =
folder_delegate_->IsPointOutsideOfFolderBoundary(pt);
if (is_item_dragged_out_of_folder) {
if (!drag_out_of_folder_container_) {
folder_item_reparent_timer_.Start(
FROM_HERE,
base::TimeDelta::FromMilliseconds(kFolderItemReparentDelay), this,
&AppsGridView::OnFolderItemReparentTimer);
drag_out_of_folder_container_ = true;
}
} else {
folder_item_reparent_timer_.Stop();
drag_out_of_folder_container_ = false;
}
}
bool AppsGridView::IsDraggingForReparentInRootLevelGridView() const {
return (!folder_delegate_ && dragging_for_reparent_item_);
}
bool AppsGridView::IsDraggingForReparentInHiddenGridView() const {
return (folder_delegate_ && dragging_for_reparent_item_);
}
gfx::Rect AppsGridView::GetTargetIconRectInFolder(
AppListItemView* drag_item_view,
AppListItemView* folder_item_view) {
gfx::Rect view_ideal_bounds =
view_model_.ideal_bounds(view_model_.GetIndexOfView(folder_item_view));
gfx::Rect icon_ideal_bounds =
folder_item_view->GetIconBoundsForTargetViewBounds(view_ideal_bounds);
AppListFolderItem* folder_item =
static_cast<AppListFolderItem*>(folder_item_view->item());
return folder_item->GetTargetIconRectInFolderForItem(drag_item_view->item(),
icon_ideal_bounds);
}
bool AppsGridView::IsUnderOEMFolder() {
if (!folder_delegate_)
return false;
return folder_delegate_->IsOEMFolder();
}
bool AppsGridView::HandleFocusMovementInPeekingState(bool arrow_up) {
DCHECK(expand_arrow_view_);
if (expand_arrow_view_->HasFocus())
return false;
// In peeking mode, the focus is now in suggestions container.
if (arrow_up)
contents_view_->GetSearchBoxView()->search_box()->RequestFocus();
else
expand_arrow_view_->RequestFocus();
return true;
}
bool AppsGridView::HandleFocusMovementInFullscreenAllAppsState(bool arrow_up) {
// The global index is the index of focused app in all pages, assuming
// all pages except last one have |cols_*rows_per_page_| apps, including
// apps in both |view_model_| and |suggestions_container_|. For example, if
// the focused app is the n-th app in p-th page, the global index is
// |(p-1)*(cols_*rows_per_page_)+(n-1)|.
int global_index;
// |suggestions_container_| does not exist in folder view.
bool has_suggestions_app =
suggestions_container_ && suggestions_container_->num_results() > 0;
const int suggestions_app_max_num = has_suggestions_app ? cols_ : 0;
// Calculate current global focus index.
views::View* focused_view = GetFocusManager()->GetFocusedView();
if (has_suggestions_app && suggestions_container_->Contains(focused_view)) {
const std::vector<SearchResultTileItemView*>& tile_views =
suggestions_container_->tile_views();
global_index =
std::find(tile_views.begin(), tile_views.end(), focused_view) -
tile_views.begin();
DCHECK(global_index < cols_);
} else {
global_index = view_model_.GetIndexOfView(
static_cast<const AppListItemView*>(focused_view)) +
suggestions_app_max_num;
}
// Calculate target global focus index.
const int tile_total = view_model_.view_size() + suggestions_app_max_num;
const int row_total = tile_total / cols_ + ((tile_total % cols_) ? 1 : 0);
int target_global_index = global_index + (arrow_up ? -cols_ : cols_);
if (target_global_index >= tile_total &&
target_global_index < cols_ * row_total) {
// Target index is on last row, so set it to last app's global index.
target_global_index = tile_total - 1;
} else if (has_suggestions_app && target_global_index >= 0 &&
target_global_index < cols_) {
// Target index is in |suggestions_container|, set it to last suggestion
// app's index if it is outside range.
target_global_index = std::min(suggestions_container_->num_results() - 1,
target_global_index);
}
// Move focus based on target global focus index.
if (target_global_index < 0 || target_global_index >= cols_ * row_total) {
// Target index is outside apps grid view.
if (folder_delegate_ && arrow_up) {
contents_view_->apps_container_view()
->app_list_folder_view()
->folder_header_view()
->SetTextFocus();
} else {
contents_view_->GetSearchBoxView()->search_box()->RequestFocus();
}
} else if (has_suggestions_app &&
target_global_index < suggestions_container_->num_results()) {
suggestions_container_->tile_views()[target_global_index]->RequestFocus();
} else {
view_model_.view_at(target_global_index - suggestions_app_max_num)
->RequestFocus();
}
return true;
}
void AppsGridView::DispatchDragEventForReparent(Pointer pointer,
const gfx::Point& drag_point) {
folder_delegate_->DispatchDragEventForReparent(pointer, drag_point);
}
void AppsGridView::EndDragFromReparentItemInRootLevel(
bool events_forwarded_to_drag_drop_host,
bool cancel_drag) {
// EndDrag was called before if |drag_view_| is NULL.
if (!drag_view_)
return;
DCHECK(IsDraggingForReparentInRootLevelGridView());
bool cancel_reparent = cancel_drag || drop_attempt_ == DROP_FOR_NONE;
if (!events_forwarded_to_drag_drop_host && !cancel_reparent) {
CalculateDropTarget();
if (drop_attempt_ == DROP_FOR_REORDER &&
IsValidIndex(reorder_drop_target_)) {
ReparentItemForReorder(drag_view_, reorder_drop_target_);
} else if (drop_attempt_ == DROP_FOR_FOLDER &&
IsValidIndex(folder_drop_target_)) {
cancel_reparent =
!ReparentItemToAnotherFolder(drag_view_, folder_drop_target_);
} else {
NOTREACHED();
}
SetViewHidden(drag_view_, false /* show */, true /* no animate */);
}
SetAsFolderDroppingTarget(folder_drop_target_, false);
if (cancel_reparent) {
CancelFolderItemReparent(drag_view_);
} else {
// By setting |drag_view_| to NULL here, we prevent ClearDragState() from
// cleaning up the newly created AppListItemView, effectively claiming
// ownership of the newly created drag view.
drag_view_->OnDragEnded();
drag_view_ = nullptr;
}
ClearDragState();
AnimateToIdealBounds();
StopPageFlipTimer();
}
void AppsGridView::EndDragForReparentInHiddenFolderGridView() {
if (drag_and_drop_host_) {
// If we had a drag and drop proxy icon, we delete it and make the real
// item visible again.
drag_and_drop_host_->DestroyDragIconProxy();
}
SetAsFolderDroppingTarget(folder_drop_target_, false);
ClearDragState();
}
void AppsGridView::OnFolderItemRemoved() {
DCHECK(folder_delegate_);
if (item_list_)
item_list_->RemoveObserver(this);
item_list_ = nullptr;
}
void AppsGridView::UpdateOpacity() {
int app_list_y_position_in_screen =
contents_view_->app_list_view()->app_list_y_position_in_screen();
AppListView* app_list_view = contents_view_->app_list_view();
int screen_bottom = app_list_view->GetScreenBottom();
bool should_restore_opacity =
!app_list_view->is_in_drag() &&
(app_list_view->app_list_state() != AppListViewState::CLOSED);
// The opacity of suggested apps is a function of the fractional displacement
// of the app list from collapsed(0) to peeking(1) state. When the fraction
// changes from |kSuggestedAppsOpacityStartFraction| to
// |kSuggestedAppsOpacityEndFraction|, the opacity of suggested apps changes
// from 0.f to 1.0f.
float fraction =
std::max<float>(
screen_bottom - kShelfSize - app_list_y_position_in_screen, 0) /
(kPeekingAppListHeight - kShelfSize);
float opacity =
std::min(std::max((fraction - kSuggestedAppsOpacityStartFraction) /
(kSuggestedAppsOpacityEndFraction -
kSuggestedAppsOpacityStartFraction),
0.f),
1.0f);
if (suggestions_container_) {
suggestions_container_->layer()->SetOpacity(
should_restore_opacity ? 1.0f : opacity);
}
// The opacity of expand arrow during dragging from collapsed(0) to peeking(1)
// state. When the dragging amount fraction changes from
// |kExpandArrowShowStartFraction| to |kExpandArrowShowEndFraction|, the
// opacity changes from 0.f to 1.0f.
float arrow_peeking_opacity = std::min(
std::max(
(fraction + kExpandArrowShowEndFraction -
kExpandArrowShowStartFraction - 1.0f) /
(kExpandArrowShowEndFraction - kExpandArrowShowStartFraction),
0.f),
1.0f);
// The opacity of all apps indicator is a function of the fractional
// displacement of the app list from peeking(0) to fullscreen(1) state. When
// the fraction changes from |kAllAppsIndicatorOpacityStartFraction| to
// |kAllAppsIndicatorOpacityEndFraction|, the opacity of all apps indicator
// changes from 0.f to 1.0f.
float peeking_to_fullscreen_height =
contents_view_->GetDisplayHeight() - kPeekingAppListHeight;
float drag_amount =
screen_bottom - app_list_y_position_in_screen - kPeekingAppListHeight;
fraction = std::max(drag_amount / peeking_to_fullscreen_height, 0.f);
opacity = std::min(std::max((fraction + kAllAppsIndicatorOpacityEndFraction -
kAllAppsIndicatorOpacityStartFraction - 1.0f) /
(kAllAppsIndicatorOpacityEndFraction -
kAllAppsIndicatorOpacityStartFraction),
0.f),
1.0f);
if (all_apps_indicator_) {
all_apps_indicator_->layer()->SetOpacity(should_restore_opacity ? 1.0f
: opacity);
}
// The opacity of expand arrow during dragging from peeking(0) to
// fullscreen(1) state. When the dragging amount fraction changes from
// |kExpandArrowDismissStartFraction| to |kExpandArrowDismissEndFraction|, the
// opacity changes from 1.0f to 0.f;
float arrow_fullscreen_opacity =
std::min(std::max((fraction - kExpandArrowDismissEndFraction) /
(kExpandArrowDismissStartFraction -
kExpandArrowDismissEndFraction),
0.f),
1.0f);
if (expand_arrow_view_) {
if (app_list_y_position_in_screen <
(screen_bottom - kPeekingAppListHeight)) {
expand_arrow_view_->layer()->SetOpacity(
should_restore_opacity ? 1.0f : arrow_fullscreen_opacity);
} else {
expand_arrow_view_->layer()->SetOpacity(
should_restore_opacity ? 1.0f : arrow_peeking_opacity);
}
}
// Updates the opacity of all apps. The opacity of the app starting at 0.f
// when the ceterline of the app is |kAllAppsOpacityStartPx| above the bottom
// of work area and transitioning to 1.0f by the time the centerline reaches
// |kAllAppsOpacityEndPx| above the work area bottom.
float centerline_above_work_area = 0.f;
const float drag_amount_above_peeking =
screen_bottom - app_list_y_position_in_screen - kPeekingAppListHeight;
const float opacity_factor = drag_amount_above_peeking / kShelfSize;
for (int i = 0; i < view_model_.view_size(); ++i) {
AppListItemView* item_view = GetItemViewAt(i);
if (item_view == drag_view_)
continue;
gfx::Rect view_bounds = view_model_.ideal_bounds(i);
views::View::ConvertRectToScreen(this, &view_bounds);
centerline_above_work_area =
std::max<float>(screen_bottom - view_bounds.CenterPoint().y(), 0.f);
opacity = std::min(
std::max((centerline_above_work_area - kAllAppsOpacityStartPx) /
(kAllAppsOpacityEndPx - kAllAppsOpacityStartPx),
0.f),
1.0f);
// The first row of apps should be shown gradually if start with dragging up
// from PEEKING and should not be shown if start with dragging down from
// PEEKING.
Index index = GetIndexOfView(item_view);
if ((index.page == 0 && index.slot < cols_ &&
contents_view_->app_list_view()->drag_started_from_peeking()) &&
((drag_amount_above_peeking >= 0 &&
drag_amount_above_peeking <= kShelfSize) ||
(drag_amount_above_peeking < 0 &&
centerline_above_work_area >= kAllAppsOpacityStartPx))) {
opacity = std::max(opacity * opacity_factor, 0.f);
}
item_view->layer()->SetOpacity(should_restore_opacity ? 1.0f : opacity);
}
// Updates the opacity of page switcher buttons. The same rule as all apps.
if (page_switcher_view_) {
gfx::Rect switcher_bounds = page_switcher_view_->GetBoundsInScreen();
centerline_above_work_area =
std::max<float>(screen_bottom - switcher_bounds.CenterPoint().y(), 0.f);
opacity = std::min(
std::max((centerline_above_work_area - kAllAppsOpacityStartPx) /
(kAllAppsOpacityEndPx - kAllAppsOpacityStartPx),
0.f),
1.0f);
page_switcher_view_->layer()->SetOpacity(should_restore_opacity ? 1.0f
: opacity);
}
}
void AppsGridView::StartTimerToIgnoreScrollEvents() {
is_ignoring_scroll_events_ = true;
scroll_ignore_timer_.Start(FROM_HERE, kIgnoreScrollEventsDurationMs, this,
&AppsGridView::StopIgnoringScrollEvents);
}
bool AppsGridView::HandleScrollFromAppListView(int offset, ui::EventType type) {
if (!pagination_model()->IsValidPageRelative(offset <= 0 ? 1 : -1))
return false;
HandleScroll(offset, type);
return true;
}
void AppsGridView::StartDragAndDropHostDrag(const gfx::Point& grid_location) {
// When a drag and drop host is given, the item can be dragged out of the app
// list window. In that case a proxy widget needs to be used.
// Note: This code has very likely to be changed for Windows (non metro mode)
// when a |drag_and_drop_host_| gets implemented.
if (!drag_view_ || !drag_and_drop_host_)
return;
gfx::Point screen_location = grid_location;
views::View::ConvertPointToScreen(this, &screen_location);
// Determine the mouse offset to the center of the icon so that the drag and
// drop host follows this layer.
gfx::Vector2d delta =
drag_view_offset_ - drag_view_->GetLocalBounds().CenterPoint();
delta.set_y(delta.y() + drag_view_->title()->size().height() / 2);
// We have to hide the original item since the drag and drop host will do
// the OS dependent code to "lift off the dragged item".
DCHECK(!IsDraggingForReparentInRootLevelGridView());
drag_and_drop_host_->CreateDragIconProxyByLocationWithNoAnimation(
drag_view_->icon()->GetBoundsInScreen().origin(),
drag_view_->item()->icon(), drag_view_, kDragAndDropProxyScale);
SetViewHidden(drag_view_, true /* hide */, true /* no animation */);
}
void AppsGridView::DispatchDragEventToDragAndDropHost(
const gfx::Point& location_in_screen_coordinates) {
if (!drag_view_ || !drag_and_drop_host_)
return;
if (GetLocalBounds().Contains(last_drag_point_)) {
// The event was issued inside the app menu and we should get all events.
if (forward_events_to_drag_and_drop_host_) {
// The DnD host was previously called and needs to be informed that the
// session returns to the owner.
forward_events_to_drag_and_drop_host_ = false;
drag_and_drop_host_->EndDrag(true);
}
} else {
if (IsFolderItem(drag_view_->item()))
return;
// The event happened outside our app menu and we might need to dispatch.
if (forward_events_to_drag_and_drop_host_) {
// Dispatch since we have already started.
if (!drag_and_drop_host_->Drag(location_in_screen_coordinates)) {
// The host is not active any longer and we cancel the operation.
forward_events_to_drag_and_drop_host_ = false;
drag_and_drop_host_->EndDrag(true);
}
} else {
if (drag_and_drop_host_->StartDrag(drag_view_->item()->id(),
location_in_screen_coordinates)) {
// From now on we forward the drag events.
forward_events_to_drag_and_drop_host_ = true;
// Any flip operations are stopped.
StopPageFlipTimer();
}
}
}
}
void AppsGridView::MaybeStartPageFlipTimer(const gfx::Point& drag_point) {
if (!IsPointWithinPageFlipBuffer(drag_point))
StopPageFlipTimer();
int new_page_flip_target = -1;
// Drag zones are at the edges of the scroll axis.
if (pagination_controller_->scroll_axis() ==
PaginationController::SCROLL_AXIS_VERTICAL) {
if (drag_point.y() < kPageFlipZoneSize)
new_page_flip_target = pagination_model_.selected_page() - 1;
else if (drag_point.y() > height() - kPageFlipZoneSize)
new_page_flip_target = pagination_model_.selected_page() + 1;
} else {
if (page_switcher_view_->bounds().Contains(drag_point)) {
gfx::Point page_switcher_point(drag_point);
views::View::ConvertPointToTarget(this, page_switcher_view_,
&page_switcher_point);
new_page_flip_target =
page_switcher_view_->GetPageForPoint(page_switcher_point);
}
// TODO(xiyuan): Fix this for RTL.
if (new_page_flip_target == -1 && drag_point.x() < kPageFlipZoneSize)
new_page_flip_target = pagination_model_.selected_page() - 1;
if (new_page_flip_target == -1 &&
drag_point.x() > width() - kPageFlipZoneSize) {
new_page_flip_target = pagination_model_.selected_page() + 1;
}
}
if (new_page_flip_target == page_flip_target_)
return;
StopPageFlipTimer();
if (pagination_model_.is_valid_page(new_page_flip_target)) {
page_flip_target_ = new_page_flip_target;
if (page_flip_target_ != pagination_model_.selected_page()) {
page_flip_timer_.Start(
FROM_HERE, base::TimeDelta::FromMilliseconds(page_flip_delay_in_ms_),
this, &AppsGridView::OnPageFlipTimer);
}
}
}
void AppsGridView::OnPageFlipTimer() {
DCHECK(pagination_model_.is_valid_page(page_flip_target_));
pagination_model_.SelectPage(page_flip_target_, true);
UMA_HISTOGRAM_ENUMERATION(kAppListPageSwitcherSourceHistogram,
kDragAppToBorder, kMaxAppListPageSwitcherSource);
}
void AppsGridView::MoveItemInModel(AppListItemView* item_view,
const Index& target) {
int current_model_index = view_model_.GetIndexOfView(item_view);
DCHECK_GE(current_model_index, 0);
int target_model_index = GetModelIndexFromIndex(target);
if (target_model_index == current_model_index)
return;
item_list_->RemoveObserver(this);
item_list_->MoveItem(current_model_index, target_model_index);
view_model_.Move(current_model_index, target_model_index);
item_list_->AddObserver(this);
if (pagination_model_.selected_page() != target.page)
pagination_model_.SelectPage(target.page, false);
}
void AppsGridView::MoveItemToFolder(AppListItemView* item_view,
const Index& target) {
const std::string& source_item_id = item_view->item()->id();
AppListItemView* target_view =
GetViewDisplayedAtSlotOnCurrentPage(target.slot);
DCHECK(target_view);
const std::string& target_view_item_id = target_view->item()->id();
// Check that the item is not being dropped onto itself; this should not
// happen, but it can if something allows multiple views to share an
// item (e.g., if a folder drop does not clean up properly).
DCHECK_NE(source_item_id, target_view_item_id);
// Make change to data model.
item_list_->RemoveObserver(this);
std::string folder_item_id =
model_->MergeItems(target_view_item_id, source_item_id);
item_list_->AddObserver(this);
if (folder_item_id.empty()) {
LOG(ERROR) << "Unable to merge into item id: " << target_view_item_id;
return;
}
if (folder_item_id != target_view_item_id) {
// New folder was created, change the view model to replace the old target
// view with the new folder item view.
size_t folder_item_index;
if (item_list_->FindItemIndex(folder_item_id, &folder_item_index)) {
int target_view_index = view_model_.GetIndexOfView(target_view);
gfx::Rect target_view_bounds = target_view->bounds();
DeleteItemViewAtIndex(target_view_index);
AppListItemView* target_folder_view =
CreateViewForItemAtIndex(folder_item_index);
target_folder_view->SetBoundsRect(target_view_bounds);
view_model_.Add(target_folder_view, target_view_index);
AddChildView(target_folder_view);
} else {
LOG(ERROR) << "Folder no longer in item_list: " << folder_item_id;
}
}
// Fade out the drag_view_ and delete it when animation ends.
int drag_view_index = view_model_.GetIndexOfView(drag_view_);
view_model_.Remove(drag_view_index);
bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
bounds_animator_.SetAnimationDelegate(
drag_view_, std::unique_ptr<gfx::AnimationDelegate>(
new ItemRemoveAnimationDelegate(drag_view_)));
UpdatePaging();
}
void AppsGridView::ReparentItemForReorder(AppListItemView* item_view,
const Index& target) {
item_list_->RemoveObserver(this);
model_->RemoveObserver(this);
AppListItem* reparent_item = item_view->item();
DCHECK(reparent_item->IsInFolder());
const std::string source_folder_id = reparent_item->folder_id();
AppListFolderItem* source_folder =
static_cast<AppListFolderItem*>(item_list_->FindItem(source_folder_id));
int target_model_index = GetModelIndexFromIndex(target);
// Remove the source folder view if there is only 1 item in it, since the
// source folder will be deleted after its only child item removed from it.
if (source_folder->ChildItemCount() == 1u) {
const int deleted_folder_index =
view_model_.GetIndexOfView(activated_folder_item_view());
DeleteItemViewAtIndex(deleted_folder_index);
// Adjust |target_model_index| if it is beyond the deleted folder index.
if (target_model_index > deleted_folder_index)
--target_model_index;
}
// Move the item from its parent folder to top level item list.
// Must move to target_model_index, the location we expect the target item
// to be, not the item location we want to insert before.
int current_model_index = view_model_.GetIndexOfView(item_view);
syncer::StringOrdinal target_position;
if (target_model_index < static_cast<int>(item_list_->item_count()))
target_position = item_list_->item_at(target_model_index)->position();
model_->MoveItemToFolderAt(reparent_item, "", target_position);
view_model_.Move(current_model_index, target_model_index);
RemoveLastItemFromReparentItemFolderIfNecessary(source_folder_id);
item_list_->AddObserver(this);
model_->AddObserver(this);
UpdatePaging();
}
bool AppsGridView::ReparentItemToAnotherFolder(AppListItemView* item_view,
const Index& target) {
DCHECK(IsDraggingForReparentInRootLevelGridView());
AppListItemView* target_view =
GetViewDisplayedAtSlotOnCurrentPage(target.slot);
if (!target_view)
return false;
AppListItem* reparent_item = item_view->item();
DCHECK(reparent_item->IsInFolder());
const std::string source_folder_id = reparent_item->folder_id();
AppListFolderItem* source_folder =
static_cast<AppListFolderItem*>(item_list_->FindItem(source_folder_id));
AppListItem* target_item = target_view->item();
// An app is being reparented to its original folder. Just cancel the
// reparent.
if (target_item->id() == reparent_item->folder_id())
return false;
// Make change to data model.
item_list_->RemoveObserver(this);
// Remove the source folder view if there is only 1 item in it, since the
// source folder will be deleted after its only child item merged into the
// target item.
if (source_folder->ChildItemCount() == 1u)
DeleteItemViewAtIndex(
view_model_.GetIndexOfView(activated_folder_item_view()));
// Move item to the target folder.
std::string target_id_after_merge =
model_->MergeItems(target_item->id(), reparent_item->id());
if (target_id_after_merge.empty()) {
LOG(ERROR) << "Unable to reparent to item id: " << target_item->id();
item_list_->AddObserver(this);
return false;
}
if (target_id_after_merge != target_item->id()) {
// New folder was created, change the view model to replace the old target
// view with the new folder item view.
const std::string& new_folder_id = reparent_item->folder_id();
size_t new_folder_index;
if (item_list_->FindItemIndex(new_folder_id, &new_folder_index)) {
int target_view_index = view_model_.GetIndexOfView(target_view);
DeleteItemViewAtIndex(target_view_index);
AppListItemView* new_folder_view =
CreateViewForItemAtIndex(new_folder_index);
view_model_.Add(new_folder_view, target_view_index);
AddChildView(new_folder_view);
} else {
LOG(ERROR) << "Folder no longer in item_list: " << new_folder_id;
}
}
RemoveLastItemFromReparentItemFolderIfNecessary(source_folder_id);
item_list_->AddObserver(this);
// Fade out the drag_view_ and delete it when animation ends.
int drag_view_index = view_model_.GetIndexOfView(drag_view_);
view_model_.Remove(drag_view_index);
bounds_animator_.AnimateViewTo(drag_view_, drag_view_->bounds());
bounds_animator_.SetAnimationDelegate(
drag_view_, std::unique_ptr<gfx::AnimationDelegate>(
new ItemRemoveAnimationDelegate(drag_view_)));
UpdatePaging();
return true;
}
// After moving the re-parenting item out of the folder, if there is only 1 item
// left, remove the last item out of the folder, delete the folder and insert it
// to the data model at the same position. Make the same change to view_model_
// accordingly.
void AppsGridView::RemoveLastItemFromReparentItemFolderIfNecessary(
const std::string& source_folder_id) {
AppListFolderItem* source_folder =
static_cast<AppListFolderItem*>(item_list_->FindItem(source_folder_id));
if (!source_folder || source_folder->ChildItemCount() != 1u)
return;
// Delete view associated with the folder item to be removed.
DeleteItemViewAtIndex(
view_model_.GetIndexOfView(activated_folder_item_view()));
// Now make the data change to remove the folder item in model.
AppListItem* last_item = source_folder->item_list()->item_at(0);
model_->MoveItemToFolderAt(last_item, "", source_folder->position());
// Create a new item view for the last item in folder.
size_t last_item_index;
if (!item_list_->FindItemIndex(last_item->id(), &last_item_index) ||
last_item_index > static_cast<size_t>(view_model_.view_size())) {
NOTREACHED();
return;
}
AppListItemView* last_item_view = CreateViewForItemAtIndex(last_item_index);
view_model_.Add(last_item_view, last_item_index);
AddChildView(last_item_view);
}
void AppsGridView::CancelFolderItemReparent(AppListItemView* drag_item_view) {
// The icon of the dragged item must target to its final ideal bounds after
// the animation completes.
CalculateIdealBounds();
gfx::Rect target_icon_rect =
GetTargetIconRectInFolder(drag_item_view, activated_folder_item_view_);
gfx::Rect drag_view_icon_to_grid =
drag_item_view->ConvertRectToParent(drag_item_view->GetIconBounds());
drag_view_icon_to_grid.ClampToCenteredSize(
gfx::Size(kGridIconDimension, kGridIconDimension));
TopIconAnimationView* icon_view =
new TopIconAnimationView(drag_item_view->item()->icon(), target_icon_rect,
false); /* animate like closing folder */
AddChildView(icon_view);
icon_view->SetBoundsRect(drag_view_icon_to_grid);
icon_view->TransformView();
}
void AppsGridView::CancelContextMenusOnCurrentPage() {
Index start_index(pagination_model_.selected_page(), 0);
int start = GetModelIndexFromIndex(start_index);
int end =
std::min(view_model_.view_size(), start + TilesPerPage(start_index.page));
for (int i = start; i < end; ++i)
GetItemViewAt(i)->CancelContextMenu();
}
void AppsGridView::DeleteItemViewAtIndex(int index) {
AppListItemView* item_view = GetItemViewAt(index);
view_model_.Remove(index);
if (item_view == drag_view_)
drag_view_ = nullptr;
delete item_view;
}
bool AppsGridView::IsPointWithinDragBuffer(const gfx::Point& point) const {
gfx::Rect rect(GetLocalBounds());
rect.Inset(-kDragBufferPx, -kDragBufferPx, -kDragBufferPx, -kDragBufferPx);
return rect.Contains(point);
}
bool AppsGridView::IsPointWithinPageFlipBuffer(const gfx::Point& point) const {
gfx::Point point_in_screen = point;
ConvertPointToScreen(this, &point_in_screen);
const display::Display display =
display::Screen::GetScreen()->GetDisplayNearestView(
GetWidget()->GetNativeView());
return display.work_area().Contains(point_in_screen);
}
void AppsGridView::ButtonPressed(views::Button* sender,
const ui::Event& event) {
if (dragging())
return;
if (strcmp(sender->GetClassName(), AppListItemView::kViewClassName))
return;
// Always set the previous activated_folder_item_view_ to be visible. This
// prevents a case where the item would remain hidden due the
// |activated_folder_item_view_| changing during the animation. We only
// need to track |activated_folder_item_view_| in the root level grid view.
AppListItemView* pressed_item_view = static_cast<AppListItemView*>(sender);
if (!folder_delegate_) {
if (activated_folder_item_view_)
activated_folder_item_view_->SetVisible(true);
if (IsFolderItem(pressed_item_view->item()))
activated_folder_item_view_ = pressed_item_view;
else
activated_folder_item_view_ = nullptr;
}
contents_view_->app_list_main_view()->ActivateApp(pressed_item_view->item(),
event.flags());
}
void AppsGridView::OnListItemAdded(size_t index, AppListItem* item) {
EndDrag(true);
AppListItemView* view = CreateViewForItemAtIndex(index);
view_model_.Add(view, index);
AddChildView(view);
if (is_fullscreen_app_list_enabled_) {
// Ensure that AppListItems that are added to the AppListItemList are not
// shown while in PEEKING. The visibility of the app icons will be updated
// on drag/animation from PEEKING.
view->SetVisible(model_->state_fullscreen() != AppListViewState::PEEKING);
}
UpdatePaging();
UpdatePulsingBlockViews();
Layout();
SchedulePaint();
}
void AppsGridView::OnListItemRemoved(size_t index, AppListItem* item) {
EndDrag(true);
DeleteItemViewAtIndex(index);
UpdatePaging();
UpdatePulsingBlockViews();
Layout();
SchedulePaint();
}
void AppsGridView::OnListItemMoved(size_t from_index,
size_t to_index,
AppListItem* item) {
EndDrag(true);
view_model_.Move(from_index, to_index);
UpdatePaging();
AnimateToIdealBounds();
}
void AppsGridView::OnAppListItemHighlight(size_t index, bool highlight) {
AppListItemView* view = GetItemViewAt(index);
view->SetItemIsHighlighted(highlight);
if (highlight)
EnsureViewVisible(GetIndexFromModelIndex(index));
}
void AppsGridView::TotalPagesChanged() {}
void AppsGridView::SelectedPageChanged(int old_selected, int new_selected) {
if (dragging()) {
CalculateDropTarget();
Layout();
MaybeStartPageFlipTimer(last_drag_point_);
} else {
ClearSelectedView(selected_view_);
Layout();
}
}
void AppsGridView::TransitionStarted() {
CancelContextMenusOnCurrentPage();
pagination_animation_start_frame_number_ =
GetCompositorActivatedFrameCount(layer());
}
void AppsGridView::TransitionChanged() {
// Update layout for valid page transition only since over-scroll no longer
// animates app icons.
const PaginationModel::Transition& transition =
pagination_model_.transition();
if (pagination_model_.is_valid_page(transition.target_page))
Layout();
}
void AppsGridView::TransitionEnded() {
const base::TimeDelta duration =
pagination_model_.GetTransitionAnimationSlideDuration();
const int end_frame_number = GetCompositorActivatedFrameCount(layer());
if (end_frame_number > pagination_animation_start_frame_number_ &&
!duration.is_zero()) {
pagination_animation_metrics_reporter_->Report(CalculateAnimationSmoothness(
end_frame_number - pagination_animation_start_frame_number_, duration,
layer()));
}
}
void AppsGridView::OnAppListModelStatusChanged() {
UpdatePulsingBlockViews();
Layout();
SchedulePaint();
}
void AppsGridView::SetViewHidden(AppListItemView* view,
bool hide,
bool immediate) {
ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
animator.SetPreemptionStrategy(
immediate ? ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET
: ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
view->layer()->SetOpacity(hide ? 0 : 1);
}
void AppsGridView::OnImplicitAnimationsCompleted() {
if (layer()->opacity() == 0.0f)
SetVisible(false);
}
void AppsGridView::StopIgnoringScrollEvents() {
is_ignoring_scroll_events_ = false;
}
bool AppsGridView::EnableFolderDragDropUI() {
// Enable drag and drop folder UI only if it is at the app list root level.
return !folder_delegate_;
}
AppsGridView::Index AppsGridView::GetNearestTileIndexForPoint(
const gfx::Point& point) const {
gfx::Rect bounds = GetContentsBounds();
const int current_page = pagination_model_.selected_page();
bounds.Inset(0, GetHeightOnTopOfAllAppsTiles(current_page), 0, 0);
const gfx::Size total_tile_size = GetTotalTileSize();
int col = base::ClampToRange(
(point.x() - bounds.x()) / total_tile_size.width(), 0, cols_ - 1);
int row = rows_per_page_;
bool show_suggested_apps =
is_fullscreen_app_list_enabled_ && current_page == 0;
row = base::ClampToRange((point.y() - bounds.y()) / total_tile_size.height(),
0, rows_per_page_ - (show_suggested_apps ? 2 : 1));
return Index(current_page, row * cols_ + col);
}
gfx::Size AppsGridView::GetTileGridSize() const {
if (is_fullscreen_app_list_enabled_)
return gfx::Size(kAppsGridPreferredWidth, kAppsGridPreferredHeight);
gfx::Rect bounds = GetExpectedTileBounds(Index(0, 0));