123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625 |
- // 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 <utility>
- #include "ash/app_list/app_list_controller_impl.h"
- #include "ash/app_list/views/app_drag_icon_proxy.h"
- #include "ash/app_list/views/ghost_image_view.h"
- #include "ash/constants/ash_features.h"
- #include "ash/keyboard/keyboard_util.h"
- #include "ash/keyboard/ui/keyboard_ui_controller.h"
- #include "ash/public/cpp/metrics_util.h"
- #include "ash/public/cpp/shelf_model.h"
- #include "ash/public/cpp/shelf_types.h"
- #include "ash/public/cpp/window_properties.h"
- #include "ash/screen_util.h"
- #include "ash/session/session_controller_impl.h"
- #include "ash/shelf/hotseat_widget.h"
- #include "ash/shelf/scrollable_shelf_view.h"
- #include "ash/shelf/shelf.h"
- #include "ash/shelf/shelf_app_button.h"
- #include "ash/shelf/shelf_application_menu_model.h"
- #include "ash/shelf/shelf_button.h"
- #include "ash/shelf/shelf_context_menu_model.h"
- #include "ash/shelf/shelf_controller.h"
- #include "ash/shelf/shelf_focus_cycler.h"
- #include "ash/shelf/shelf_layout_manager.h"
- #include "ash/shelf/shelf_menu_model_adapter.h"
- #include "ash/shelf/shelf_tooltip_manager.h"
- #include "ash/shelf/shelf_widget.h"
- #include "ash/shell.h"
- #include "ash/shell_delegate.h"
- #include "ash/strings/grit/ash_strings.h"
- #include "ash/style/ash_color_provider.h"
- #include "ash/system/status_area_widget.h"
- #include "ash/utility/haptics_util.h"
- #include "ash/wm/desks/desks_util.h"
- #include "ash/wm/mru_window_tracker.h"
- #include "ash/wm/tablet_mode/tablet_mode_controller.h"
- #include "ash/wm/window_util.h"
- #include "base/auto_reset.h"
- #include "base/bind.h"
- #include "base/callback_helpers.h"
- #include "base/containers/adapters.h"
- #include "base/containers/contains.h"
- #include "base/cxx17_backports.h"
- #include "base/metrics/histogram_functions.h"
- #include "base/metrics/histogram_macros.h"
- #include "base/metrics/user_metrics.h"
- #include "base/scoped_observation.h"
- #include "base/strings/utf_string_conversions.h"
- #include "base/timer/timer.h"
- #include "components/account_id/account_id.h"
- #include "components/services/app_service/public/cpp/app_registry_cache_wrapper.h"
- #include "components/services/app_service/public/cpp/app_types.h"
- #include "ui/accessibility/ax_node_data.h"
- #include "ui/base/l10n/l10n_util.h"
- #include "ui/base/metadata/metadata_impl_macros.h"
- #include "ui/base/models/simple_menu_model.h"
- #include "ui/base/ui_base_features.h"
- #include "ui/color/color_id.h"
- #include "ui/compositor/animation_throughput_reporter.h"
- #include "ui/compositor/layer.h"
- #include "ui/compositor/layer_animation_observer.h"
- #include "ui/compositor/layer_animator.h"
- #include "ui/compositor/scoped_animation_duration_scale_mode.h"
- #include "ui/compositor/scoped_layer_animation_settings.h"
- #include "ui/display/scoped_display_for_new_windows.h"
- #include "ui/events/devices/haptic_touchpad_effects.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/animation/ink_drop.h"
- #include "ui/views/controls/button/button.h"
- #include "ui/views/controls/menu/menu_model_adapter.h"
- #include "ui/views/controls/menu/menu_runner.h"
- #include "ui/views/controls/separator.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 rip off distance, where the shelf icon gets unpinned if dragged over this
- // distance from the outer edge of the shelf, depends on the shelf size. The
- // distance is calculated by multiplying the shelf size by
- // `kRipOffDistanceFactor`.
- constexpr float kRipOffDistanceFactor = 0.75f;
- // The rip off drag and drop proxy image should get scaled by this factor.
- constexpr float kDragAndDropProxyScale = 1.2f;
- // The opacity represents that this partially disappeared item will get removed.
- constexpr float kDraggedImageOpacity = 0.5f;
- namespace {
- // The dimensions, in pixels, of the separator between pinned and unpinned
- // items.
- constexpr int kSeparatorSize = 20;
- constexpr int kSeparatorThickness = 1;
- constexpr char kShelfIconMoveAnimationHistogram[] =
- "Ash.ShelfIcon.AnimationSmoothness.Move";
- constexpr char kShelfIconFadeInAnimationHistogram[] =
- "Ash.ShelfIcon.AnimationSmoothness.FadeIn";
- constexpr char kShelfIconFadeOutAnimationHistogram[] =
- "Ash.ShelfIcon.AnimationSmoothness.FadeOut";
- // Helper to check if tablet mode is enabled.
- bool IsTabletModeEnabled() {
- return Shell::Get()->tablet_mode_controller() &&
- Shell::Get()->tablet_mode_controller()->InTabletMode();
- }
- // 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(base::Milliseconds(1));
- }
- BoundsAnimatorDisabler(const BoundsAnimatorDisabler&) = delete;
- BoundsAnimatorDisabler& operator=(const BoundsAnimatorDisabler&) = delete;
- ~BoundsAnimatorDisabler() {
- bounds_animator_->SetAnimationDuration(old_duration_);
- }
- private:
- // The previous animation duration.
- base::TimeDelta old_duration_;
- // The bounds animator which gets used.
- views::BoundsAnimator* bounds_animator_;
- };
- void ReportMoveAnimationSmoothness(int smoothness) {
- base::UmaHistogramPercentage(kShelfIconMoveAnimationHistogram, smoothness);
- }
- void ReportFadeInAnimationSmoothness(int smoothness) {
- base::UmaHistogramPercentage(kShelfIconFadeInAnimationHistogram, smoothness);
- }
- void ReportFadeOutAnimationSmoothness(int smoothness) {
- base::UmaHistogramPercentage(kShelfIconFadeOutAnimationHistogram, smoothness);
- }
- // Returns the id of the display on which |view| is shown.
- int64_t GetDisplayIdForView(const View* view) {
- aura::Window* window = view->GetWidget()->GetNativeWindow();
- return display::Screen::GetScreen()->GetDisplayNearestWindow(window).id();
- }
- // Whether |item_view| is a ShelfAppButton and its state is STATE_DRAGGING.
- bool ShelfButtonIsInDrag(const ShelfItemType item_type,
- const views::View* item_view) {
- switch (item_type) {
- case TYPE_PINNED_APP:
- case TYPE_BROWSER_SHORTCUT:
- case TYPE_APP:
- case TYPE_UNPINNED_BROWSER_SHORTCUT:
- return static_cast<const ShelfAppButton*>(item_view)->state() &
- ShelfAppButton::STATE_DRAGGING;
- case TYPE_DIALOG:
- case TYPE_UNDEFINED:
- return false;
- }
- }
- // Called back by the shelf item delegates to determine whether an app menu item
- // should be included in the shelf app menu given its corresponding window. This
- // is used to filter out items whose windows are on inactive desks when the per-
- // desk shelf feature is enabled.
- bool ShouldIncludeMenuItem(aura::Window* window) {
- if (!features::IsPerDeskShelfEnabled())
- return true;
- return desks_util::BelongsToActiveDesk(window);
- }
- // Returns true if the app associated with |app_id| is a Remote App.
- bool IsRemoteApp(const std::string& app_id) {
- AccountId account_id =
- Shell::Get()->session_controller()->GetActiveAccountId();
- apps::AppRegistryCache* cache =
- apps::AppRegistryCacheWrapper::Get().GetAppRegistryCache(account_id);
- return cache && cache->GetAppType(app_id) == apps::AppType::kRemote;
- }
- bool IsStandaloneBrowser(const std::string& app_id) {
- AccountId account_id =
- Shell::Get()->session_controller()->GetActiveAccountId();
- apps::AppRegistryCache* cache =
- apps::AppRegistryCacheWrapper::Get().GetAppRegistryCache(account_id);
- return cache &&
- cache->GetAppType(app_id) == apps::AppType::kStandaloneBrowser;
- }
- // Records the user metric action for whenever a shelf item is pinned or
- // unpinned.
- void RecordPinUnpinUserAction(bool pinned) {
- if (pinned) {
- base::RecordAction(base::UserMetricsAction("Shelf_ItemPinned"));
- } else {
- base::RecordAction(base::UserMetricsAction("Shelf_ItemUnpinned"));
- }
- }
- } // namespace
- // Helper class that resets a view opacity when called. Used to reset drag view
- // opacity after animation to drop the drag icon proxy to its final bounds ends.
- // The resetter is no-op if the target view gets destroyed before the resetter
- // get run.
- class ShelfView::ViewOpacityResetter : public views::ViewObserver {
- public:
- explicit ViewOpacityResetter(views::View* view) : view_(view) {
- view_observer_.Observe(view);
- }
- ViewOpacityResetter(const ViewOpacityResetter&) = delete;
- ViewOpacityResetter& operator=(const ViewOpacityResetter&) = delete;
- ~ViewOpacityResetter() override { Run(); }
- // views::ViewObserver:
- void OnViewIsDeleting(View* observed_view) override {
- view_ = nullptr;
- view_observer_.Reset();
- }
- void Run() {
- if (view_ && view_->layer())
- view_->layer()->SetOpacity(1.0f);
- }
- private:
- views::View* view_;
- base::ScopedObservation<views::View, views::ViewObserver> view_observer_{
- this};
- };
- // ImplicitAnimationObserver used when adding an item.
- class ShelfView::FadeInAnimationDelegate
- : public ui::ImplicitAnimationObserver {
- public:
- explicit FadeInAnimationDelegate(ShelfView* shelf_view)
- : shelf_view_(shelf_view) {}
- ~FadeInAnimationDelegate() override { StopObservingImplicitAnimations(); }
- private:
- // ui::ImplicitAnimationObserver:
- void OnImplicitAnimationsCompleted() override {
- shelf_view_->OnFadeInAnimationEnded();
- }
- ShelfView* shelf_view_ = nullptr;
- };
- // 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, std::unique_ptr<views::View> view)
- : shelf_view_(host), view_(std::move(view)) {}
- FadeOutAnimationDelegate(const FadeOutAnimationDelegate&) = delete;
- FadeOutAnimationDelegate& operator=(const FadeOutAnimationDelegate&) = delete;
- ~FadeOutAnimationDelegate() override = default;
- // AnimationDelegate overrides:
- void AnimationProgressed(const Animation* animation) override {
- view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
- }
- void AnimationEnded(const Animation* animation) override {
- // Ensures that |view| is not used after destruction.
- shelf_view_->StopAnimatingViewIfAny(view_.get());
- // Remove the view which has been faded away.
- view_.reset();
- shelf_view_->OnFadeOutAnimationEnded();
- }
- void AnimationCanceled(const Animation* animation) override {}
- private:
- ShelfView* shelf_view_;
- std::unique_ptr<views::View> view_;
- };
- // 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(const StartFadeAnimationDelegate&) = delete;
- StartFadeAnimationDelegate& operator=(const StartFadeAnimationDelegate&) =
- delete;
- ~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_;
- };
- // static
- const int ShelfView::kMinimumDragDistance = 8;
- ShelfView::ShelfView(ShelfModel* model,
- Shelf* shelf,
- Delegate* delegate,
- ShelfButtonDelegate* shelf_button_delegate)
- : model_(model),
- shelf_(shelf),
- view_model_(std::make_unique<views::ViewModel>()),
- bounds_animator_(
- std::make_unique<views::BoundsAnimator>(this,
- /*use_transforms=*/true)),
- delegate_(delegate),
- shelf_button_delegate_(shelf_button_delegate) {
- DCHECK(model_);
- DCHECK(shelf_);
- Shell::Get()->tablet_mode_controller()->AddObserver(this);
- Shell::Get()->AddShellObserver(this);
- shelf_->AddObserver(this);
- bounds_animator_->AddObserver(this);
- bounds_animator_->SetAnimationDuration(
- ShelfConfig::Get()->shelf_animation_duration());
- set_context_menu_controller(this);
- set_allow_deactivate_on_esc(true);
- announcement_view_ = new views::View();
- AddChildView(announcement_view_);
- }
- ShelfView::~ShelfView() {
- // Shell destroys the TabletModeController before destroying all root windows.
- if (Shell::Get()->tablet_mode_controller())
- Shell::Get()->tablet_mode_controller()->RemoveObserver(this);
- shelf_->RemoveObserver(this);
- Shell::Get()->RemoveShellObserver(this);
- bounds_animator_->RemoveObserver(this);
- model_->RemoveObserver(this);
- }
- int ShelfView::GetSizeOfAppButtons(int count, int button_size) {
- const int button_spacing = ShelfConfig::Get()->button_spacing();
- if (count == 0)
- return 0;
- const int app_size = count * button_size;
- int total_padding = button_spacing * (count - 1);
- return app_size + total_padding;
- }
- void ShelfView::Init(views::FocusSearch* focus_search) {
- auto separator = std::make_unique<views::Separator>();
- separator->SetColorId(ui::kColorAshSystemUIMenuSeparator);
- separator->SetPreferredLength(kSeparatorSize);
- separator->SetVisible(false);
- ConfigureChildView(separator.get(), ui::LAYER_TEXTURED);
- separator_ = AddChildView(std::move(separator));
- 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();
- int index = static_cast<int>(i - items.begin());
- view_model_->Add(child, index);
- // Add child view so it has the same ordering as in the |view_model_|.
- AddChildViewAt(child, index);
- }
- fade_in_animation_delegate_ = std::make_unique<FadeInAnimationDelegate>(this);
- focus_search_ = focus_search;
- // We'll layout when our bounds change.
- }
- bool ShelfView::IsShowingMenu() const {
- return shelf_menu_model_adapter_ &&
- shelf_menu_model_adapter_->IsShowingMenu();
- }
- void ShelfView::UpdateVisibleShelfItemBoundsUnion() {
- visible_shelf_item_bounds_union_.SetRect(0, 0, 0, 0);
- for (const auto i : visible_views_indices_) {
- const views::View* child = view_model_->view_at(i);
- if (ShouldShowTooltipForChildView(child)) {
- visible_shelf_item_bounds_union_.Union(
- GetChildViewTargetMirroredBounds(child));
- }
- }
- }
- bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
- if (!view || !view->parent())
- return false;
- if (view->parent() == this)
- return ShouldShowTooltipForChildView(view);
- return false;
- }
- ShelfAppButton* ShelfView::GetShelfAppButton(const ShelfID& id) {
- const int index = model_->ItemIndexByID(id);
- if (index < 0)
- return nullptr;
- views::View* const view = view_model_->view_at(index);
- DCHECK_EQ(ShelfAppButton::kViewClassName, view->GetClassName());
- return static_cast<ShelfAppButton*>(view);
- }
- void ShelfView::StopAnimatingViewIfAny(views::View* view) {
- if (bounds_animator_->IsAnimating(view))
- bounds_animator_->StopAnimatingView(view);
- }
- int ShelfView::GetButtonSize() const {
- return ShelfConfig::Get()->GetShelfButtonSize(
- shelf_->hotseat_widget()->target_hotseat_density());
- }
- int ShelfView::GetButtonIconSize() const {
- return ShelfConfig::Get()->GetShelfButtonIconSize(
- shelf_->hotseat_widget()->target_hotseat_density());
- }
- int ShelfView::GetShelfItemRippleSize() const {
- return GetButtonSize() +
- 2 * ShelfConfig::Get()->scrollable_shelf_ripple_padding();
- }
- void ShelfView::LayoutIfAppIconsOffsetUpdates() {
- if (app_icons_layout_offset_ != CalculateAppIconsLayoutOffset())
- LayoutToIdealBounds();
- }
- ShelfAppButton* ShelfView::GetShelfItemViewWithContextMenu() {
- if (context_menu_id_.IsNull())
- return nullptr;
- const int item_index = model_->ItemIndexByID(context_menu_id_);
- if (item_index < 0)
- return nullptr;
- return static_cast<ShelfAppButton*>(view_model_->view_at(item_index));
- }
- void ShelfView::AnnounceShelfItemNotificationBadge(views::View* button) {
- announcement_view_->GetViewAccessibility().OverrideName(
- l10n_util::GetStringFUTF16(IDS_SHELF_ITEM_HAS_NOTIFICATION_BADGE,
- GetTitleForView(button)));
- announcement_view_->NotifyAccessibilityEvent(ax::mojom::Event::kAlert,
- /*send_native_event=*/true);
- }
- bool ShelfView::LocationInsideVisibleShelfItemBounds(
- const gfx::Point& location) const {
- return visible_shelf_item_bounds_union_.Contains(location);
- }
- bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) const {
- // There are thin gaps between launcher buttons but the tooltip shouldn't hide
- // in the gaps, but the tooltip should hide if the mouse moved totally outside
- // of the buttons area.
- return !LocationInsideVisibleShelfItemBounds(cursor_location);
- }
- const std::vector<aura::Window*> ShelfView::GetOpenWindowsForView(
- views::View* view) {
- std::vector<aura::Window*> window_list =
- Shell::Get()->mru_window_tracker()->BuildWindowForCycleList(kActiveDesk);
- std::vector<aura::Window*> open_windows;
- const ShelfItem* item = ShelfItemForView(view);
- // The concept of a list of open windows doesn't make sense for something
- // that isn't an app shortcut: return an empty list.
- if (!item)
- return open_windows;
- for (auto* window : window_list) {
- const std::string window_app_id =
- ShelfID::Deserialize(window->GetProperty(kShelfIDKey)).app_id;
- if (window_app_id == item->id.app_id) {
- // TODO: In the very first version we only show one window. Add the proper
- // UI to show all windows for a given open app.
- open_windows.push_back(window);
- }
- }
- return open_windows;
- }
- std::u16string ShelfView::GetTitleForView(const views::View* view) const {
- if (view->parent() == this)
- return GetTitleForChildView(view);
- return std::u16string();
- }
- views::View* ShelfView::GetViewForEvent(const ui::Event& event) {
- if (event.target() == GetWidget()->GetNativeWindow())
- return this;
- return nullptr;
- }
- 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);
- }
- gfx::Size ShelfView::CalculatePreferredSize() const {
- const int hotseat_size = shelf_->hotseat_widget()->GetHotseatSize();
- if (visible_views_indices_.empty()) {
- // There are no visible shelf items.
- return shelf_->IsHorizontalAlignment() ? gfx::Size(0, hotseat_size)
- : gfx::Size(hotseat_size, 0);
- }
- const gfx::Rect last_button_bounds =
- view_model_->ideal_bounds(visible_views_indices_.back());
- if (shelf_->IsHorizontalAlignment())
- return gfx::Size(last_button_bounds.right(), hotseat_size);
- return gfx::Size(hotseat_size, last_button_bounds.bottom());
- }
- void ShelfView::OnThemeChanged() {
- views::AccessiblePaneView::OnThemeChanged();
- if (separator_)
- separator_->SchedulePaint();
- }
- 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, with
- // an exception of usage within the scrollable shelf. With scrollable shelf
- // (and hotseat), tablet mode transition causes hotseat bounds changes, so
- // animating shelf items as well would introduce a lag.
- BoundsAnimatorDisabler disabler(bounds_animator_.get());
- LayoutToIdealBounds();
- shelf_->NotifyShelfIconPositionsChanged();
- }
- bool ShelfView::OnKeyPressed(const ui::KeyEvent& event) {
- if (event.IsControlDown() &&
- keyboard_util::IsArrowKeyCode(event.key_code())) {
- bool swap_with_next = (event.key_code() == ui::VKEY_DOWN ||
- event.key_code() == ui::VKEY_RIGHT);
- SwapButtons(GetFocusManager()->GetFocusedView(), swap_with_next);
- return true;
- }
- return views::View::OnKeyPressed(event);
- }
- void ShelfView::OnMouseEvent(ui::MouseEvent* event) {
- gfx::Point location_in_screen(event->location());
- View::ConvertPointToScreen(this, &location_in_screen);
- switch (event->type()) {
- case ui::ET_MOUSEWHEEL:
- // The mousewheel event is handled by the ScrollableShelfView.
- break;
- case ui::ET_MOUSE_PRESSED:
- if (!event->IsOnlyLeftMouseButton()) {
- if (event->IsOnlyRightMouseButton()) {
- ShowContextMenuForViewImpl(this, location_in_screen,
- ui::MENU_SOURCE_MOUSE);
- event->SetHandled();
- }
- return;
- }
- [[fallthrough]];
- case ui::ET_MOUSE_DRAGGED:
- case ui::ET_MOUSE_RELEASED:
- // Convert the event location from current view to screen, since dragging
- // the shelf by mouse can open the fullscreen app list. Updating the
- // bounds of the app list during dragging is based on screen coordinate
- // space.
- event->set_location(location_in_screen);
- event->SetHandled();
- shelf_->ProcessMouseEvent(*event->AsMouseEvent());
- break;
- default:
- break;
- }
- }
- views::FocusTraversable* ShelfView::GetPaneFocusTraversable() {
- // ScrollableShelfView should handles the focus traversal.
- return nullptr;
- }
- void ShelfView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
- node_data->role = ax::mojom::Role::kToolbar;
- node_data->SetName(l10n_util::GetStringUTF8(IDS_ASH_SHELF_ACCESSIBLE_NAME));
- }
- View* ShelfView::GetTooltipHandlerForPoint(const gfx::Point& point) {
- // Similar implementation as views::View, but without going into each
- // child's subviews.
- View::Views children = GetChildrenInZOrder();
- for (auto* child : base::Reversed(children)) {
- if (!child->GetVisible())
- continue;
- gfx::Point point_in_child_coords(point);
- ConvertPointToTarget(this, child, &point_in_child_coords);
- if (child->HitTestPoint(point_in_child_coords) &&
- ShouldShowTooltipForChildView(child)) {
- return child;
- }
- }
- // If none of our children qualifies, just return the shelf view itself.
- return this;
- }
- void ShelfView::ViewHierarchyChanged(
- const views::ViewHierarchyChangedDetails& details) {
- if (!details.is_add) {
- if (details.child == current_ghost_view_) {
- current_ghost_view_ = nullptr;
- current_ghost_view_index_ = absl::nullopt;
- }
- if (details.child == last_ghost_view_) {
- last_ghost_view_ = nullptr;
- current_ghost_view_index_ = absl::nullopt;
- }
- }
- }
- void ShelfView::OnShelfButtonAboutToRequestFocusFromTabTraversal(
- ShelfButton* button,
- bool reverse) {
- if (ShouldFocusOut(reverse, button)) {
- shelf_->shelf_focus_cycler()->FocusOut(reverse, SourceView::kShelfView);
- }
- }
- void ShelfView::ButtonPressed(views::Button* sender,
- const ui::Event& event,
- views::InkDrop* ink_drop) {
- if (!ShouldEventActivateButton(sender, event)) {
- ink_drop->SnapToHidden();
- return;
- }
- // Prevent concurrent requests that may show application or context menus.
- if (!item_awaiting_response_.IsNull()) {
- const ShelfItem* item = ShelfItemForView(sender);
- if (item && item->id != item_awaiting_response_)
- ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
- return;
- }
- // Ensure the keyboard is hidden and stays hidden (as long as it isn't locked)
- if (keyboard::KeyboardUIController::Get()->IsEnabled())
- keyboard::KeyboardUIController::Get()->HideKeyboardExplicitlyBySystem();
- // Record the index for the last pressed shelf item.
- last_pressed_index_ = view_model_->GetIndexOfView(sender);
- DCHECK(last_pressed_index_.has_value());
- // Place new windows on the same display as the button. Opening windows is
- // usually an async operation so we wait until window activation changes
- // (ShelfItemStatusChanged) before destroying the scoped object. Post a task
- // to destroy the scoped object just in case the window activation event does
- // not get fired.
- aura::Window* window = sender->GetWidget()->GetNativeWindow();
- scoped_display_for_new_windows_ =
- std::make_unique<display::ScopedDisplayForNewWindows>(
- window->GetRootWindow());
- base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE,
- base::BindOnce(&ShelfView::DestroyScopedDisplay,
- weak_factory_.GetWeakPtr()),
- base::Milliseconds(100));
- // Slow down activation animations if Control key is pressed.
- std::unique_ptr<ui::ScopedAnimationDurationScaleMode> slowing_animations;
- if (event.IsControlDown()) {
- slowing_animations = std::make_unique<ui::ScopedAnimationDurationScaleMode>(
- ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
- }
- // Collect usage statistics before we decide what to do with the click.
- switch (model_->items()[last_pressed_index_.value()].type) {
- case TYPE_PINNED_APP:
- case TYPE_BROWSER_SHORTCUT:
- case TYPE_APP:
- case TYPE_UNPINNED_BROWSER_SHORTCUT:
- base::RecordAction(base::UserMetricsAction("Launcher_ClickOnApp"));
- break;
- 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_.value()];
- if (!model_->GetShelfItemDelegate(item.id)) {
- AfterItemSelected(item, sender, event.Clone(), ink_drop, SHELF_ACTION_NONE,
- {});
- return;
- }
- // Notify the item of its selection; handle the result in AfterItemSelected.
- item_awaiting_response_ = item.id;
- model_->GetShelfItemDelegate(item.id)->ItemSelected(
- event.Clone(), GetDisplayIdForView(this), LAUNCH_FROM_SHELF,
- base::BindOnce(&ShelfView::AfterItemSelected, weak_factory_.GetWeakPtr(),
- item, sender, event.Clone(), ink_drop),
- base::BindRepeating(&ShouldIncludeMenuItem));
- }
- bool ShelfView::IsShowingMenuForView(const views::View* view) const {
- return IsShowingMenu() &&
- shelf_menu_model_adapter_->IsShowingMenuForView(*view);
- }
- ////////////////////////////////////////////////////////////////////////////////
- // ShelfView, FocusTraversable implementation:
- views::FocusSearch* ShelfView::GetFocusSearch() {
- return focus_search_;
- }
- ////////////////////////////////////////////////////////////////////////////////
- // ShelfView, AccessiblePaneView implementation:
- views::View* ShelfView::GetDefaultFocusableChild() {
- return default_last_focusable_child_ ? FindLastFocusableChild()
- : FindFirstFocusableChild();
- }
- void ShelfView::ShowContextMenuForViewImpl(views::View* source,
- const gfx::Point& point,
- ui::MenuSourceType source_type) {
- // Prevent concurrent requests that may show application or context menus.
- const ShelfItem* item = ShelfItemForView(source);
- if (!item_awaiting_response_.IsNull()) {
- if (item && item->id != item_awaiting_response_) {
- views::InkDrop::Get(source)->AnimateToState(
- views::InkDropState::DEACTIVATED, nullptr);
- }
- return;
- }
- last_pressed_index_ = absl::nullopt;
- if (!item || !model_->GetShelfItemDelegate(item->id)) {
- ShowShelfContextMenu(ShelfID(), point, source, source_type, nullptr);
- return;
- }
- item_awaiting_response_ = item->id;
- context_menu_callback_.Reset(base::BindOnce(
- &ShelfView::ShowShelfContextMenu, weak_factory_.GetWeakPtr(), item->id,
- point, source, source_type));
- const int64_t display_id = GetDisplayIdForView(this);
- model_->GetShelfItemDelegate(item->id)->GetContextMenu(
- display_id, context_menu_callback_.callback());
- }
- void ShelfView::OnTabletModeStarted() {
- // Close all menus when tablet mode starts to ensure that the clamshell only
- // context menu options are not available in tablet mode.
- if (shelf_menu_model_adapter_)
- shelf_menu_model_adapter_->Cancel();
- }
- void ShelfView::OnTabletModeEnded() {
- // Close all menus when tablet mode ends so that menu options are kept
- // consistent with device state.
- if (shelf_menu_model_adapter_)
- shelf_menu_model_adapter_->Cancel();
- }
- void ShelfView::OnShelfConfigUpdated() {
- // Ensure the shelf app buttons have an icon which is up to date with the
- // current ShelfConfig sizing.
- for (size_t i = 0; i < view_model_->view_size(); i++) {
- ShelfAppButton* button =
- static_cast<ShelfAppButton*>(view_model_->view_at(i));
- if (!button->IsIconSizeCurrent())
- ShelfItemChanged(i, model_->items()[i]);
- }
- }
- bool ShelfView::ShouldEventActivateButton(View* view, const ui::Event& event) {
- // This only applies to app buttons.
- DCHECK_EQ(ShelfAppButton::kViewClassName, view->GetClassName());
- 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;
- const bool repost = IsRepostEvent(event);
- // Ignore if this is a repost event on the last pressed shelf item.
- auto index = view_model_->GetIndexOfView(view);
- if (!index.has_value())
- return false;
- return !repost || last_pressed_index_ != index;
- }
- bool ShelfView::IsDraggedView(const views::View* view) const {
- return drag_view_ == view;
- }
- views::View* ShelfView::FindFirstFocusableChild() {
- if (visible_views_indices_.empty())
- return nullptr;
- return view_model_->view_at(visible_views_indices_.front());
- }
- views::View* ShelfView::FindLastFocusableChild() {
- if (visible_views_indices_.empty())
- return nullptr;
- return view_model_->view_at(visible_views_indices_.back());
- }
- views::View* ShelfView::FindFirstOrLastFocusableChild(bool last) {
- return last ? FindLastFocusableChild() : FindFirstFocusableChild();
- }
- bool ShelfView::HandleGestureEvent(const ui::GestureEvent* event) {
- // Avoid changing |event|'s location since |event| may be received by post
- // event handlers.
- ui::GestureEvent copy_event(*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(copy_event.location());
- View::ConvertPointToScreen(this, &location_in_screen);
- copy_event.set_location(location_in_screen);
- if (shelf_->ProcessGestureEvent(copy_event))
- return true;
- return false;
- }
- bool ShelfView::ShouldShowTooltipForChildView(
- const views::View* child_view) const {
- DCHECK_EQ(this, child_view->parent());
- // Don't show a tooltip for a view that's currently being dragged.
- if (child_view == drag_view_)
- return false;
- return ShelfItemForView(child_view) && !IsShowingMenuForView(child_view);
- }
- // static
- void ShelfView::ConfigureChildView(views::View* view,
- ui::LayerType layer_type) {
- view->SetPaintToLayer(layer_type);
- view->layer()->SetFillsBoundsOpaquely(false);
- }
- void ShelfView::CalculateIdealBounds() {
- DCHECK(static_cast<size_t>(model()->item_count()) ==
- view_model_->view_size());
- const int button_spacing = ShelfConfig::Get()->button_spacing();
- UpdateSeparatorIndex();
- const int hotseat_size = shelf_->hotseat_widget()->GetHotseatSize();
- // Don't show the separator if it isn't needed, or would appear after all
- // visible items.
- separator_->SetVisible(separator_index_.has_value() &&
- separator_index_ < visible_views_indices_.back());
- // Set |separator_index_| to nullopt if it is not visible.
- if (!separator_->GetVisible())
- separator_index_ = absl::nullopt;
- app_icons_layout_offset_ = CalculateAppIconsLayoutOffset();
- int x = shelf()->PrimaryAxisValue(app_icons_layout_offset_, 0);
- int y = shelf()->PrimaryAxisValue(0, app_icons_layout_offset_);
- // The padding is handled in ScrollableShelfView.
- const int button_size = GetButtonSize();
- for (size_t i = 0; i < view_model_->view_size(); ++i) {
- if (view_model_->view_at(i)->GetVisible()) {
- gfx::Rect ideal_view_bounds(x, y, button_size, button_size);
- view_model_->set_ideal_bounds(i, ideal_view_bounds);
- if (view_model_->view_at(i) == drag_view_ &&
- current_ghost_view_index_ != i && !dragged_off_shelf_) {
- if (current_ghost_view_)
- current_ghost_view_->FadeOut();
- last_ghost_view_ = current_ghost_view_;
- auto current_ghost_view = std::make_unique<GhostImageView>(GridIndex());
- gfx::Size icon_size = drag_view_
- ->GetIdealIconBounds(ideal_view_bounds.size(),
- /*icon_scale=*/1.0f)
- .size();
- gfx::Rect ghost_view_bounds = ideal_view_bounds;
- // Ensure that the ghost_view_bounds are a square that encloses the
- // icon_size with the same center. The ghost view should draw as a
- // circle.
- const int icon_width = std::min(icon_size.width(), icon_size.height());
- ghost_view_bounds.ClampToCenteredSize(
- gfx::Size(icon_width, icon_width));
- current_ghost_view->Init(ghost_view_bounds,
- ghost_view_bounds.width() / 2);
- current_ghost_view_ = AddChildView(std::move(current_ghost_view));
- current_ghost_view_->FadeIn();
- current_ghost_view_index_ = i;
- }
- x = shelf()->PrimaryAxisValue(x + button_size + button_spacing, x);
- y = shelf()->PrimaryAxisValue(y, y + button_size + button_spacing);
- } else {
- view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
- }
- if (i == separator_index_) {
- // Place the separator halfway between the two icons it separates,
- // vertically centered.
- int half_space = button_spacing / 2;
- int secondary_offset = (hotseat_size - kSeparatorSize) / 2;
- x -= shelf()->PrimaryAxisValue(half_space, 0);
- y -= shelf()->PrimaryAxisValue(0, half_space);
- separator_->SetBounds(
- x + shelf()->PrimaryAxisValue(0, secondary_offset),
- y + shelf()->PrimaryAxisValue(secondary_offset, 0),
- shelf()->PrimaryAxisValue(kSeparatorThickness, kSeparatorSize),
- shelf()->PrimaryAxisValue(kSeparatorSize, kSeparatorThickness));
- x += shelf()->PrimaryAxisValue(half_space, 0);
- y += shelf()->PrimaryAxisValue(0, half_space);
- }
- }
- }
- views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
- views::View* view = nullptr;
- switch (item.type) {
- case TYPE_PINNED_APP:
- case TYPE_BROWSER_SHORTCUT:
- case TYPE_APP:
- case TYPE_UNPINNED_BROWSER_SHORTCUT:
- case TYPE_DIALOG: {
- ShelfAppButton* button = new ShelfAppButton(
- this, shelf_button_delegate_ ? shelf_button_delegate_ : this);
- button->SetImage(item.image);
- button->SetNotificationBadgeColor(item.notification_badge_color);
- button->ReflectItemStatus(item);
- view = button;
- break;
- }
- case TYPE_UNDEFINED:
- return nullptr;
- }
- view->set_context_menu_controller(this);
- ConfigureChildView(view, ui::LAYER_NOT_DRAWN);
- return view;
- }
- int ShelfView::GetAvailableSpaceForAppIcons() const {
- return shelf()->PrimaryAxisValue(width(), height());
- }
- void ShelfView::UpdateSeparatorIndex() {
- // A separator is shown after the last pinned item only if it's followed by a
- // visible app item.
- absl::optional<size_t> first_unpinned_index = absl::nullopt;
- absl::optional<size_t> last_pinned_index = absl::nullopt;
- absl::optional<size_t> dragged_item_index = absl::nullopt;
- if (drag_view_)
- dragged_item_index = view_model_->GetIndexOfView(drag_view_);
- const bool can_drag_view_across_separator =
- drag_view_ && CanDragAcrossSeparator(drag_view_);
- for (size_t index = model()->item_count(); index > 0; --index) {
- const size_t i = index - 1;
- const auto& item = model()->items()[i];
- if (IsItemPinned(item)) {
- // Dragged pinned item may be moved to the unpinned side of the shelf and
- // may end up right of an unpinned app. Dismisses the dragged item to
- // check the next one.
- if (i == dragged_item_index && can_drag_view_across_separator)
- continue;
- last_pinned_index = i;
- break;
- }
- if (item.type == TYPE_APP && item.is_on_active_desk)
- first_unpinned_index = i;
- }
- // If there is no unpinned item in shelf, return -1 as the separator should be
- // hidden.
- if (!first_unpinned_index.has_value()) {
- separator_index_ = absl::nullopt;
- return;
- }
- // If the dragged item is between the pinned apps and unpinned apps, move it
- // to the pinned app side if it is closer to the pinned section compared to
- // its ideal bounds.
- if (can_drag_view_across_separator &&
- last_pinned_index < dragged_item_index &&
- dragged_item_index <= first_unpinned_index &&
- drag_view_relative_to_ideal_bounds_ == RelativePosition::kLeft) {
- separator_index_ = dragged_item_index;
- return;
- }
- separator_index_ = last_pinned_index;
- }
- bool ShelfView::ShouldHandleDrag(const std::string& app_id,
- const gfx::Point& location_in_screen) const {
- // Remote Apps are not pinnable.
- if (IsRemoteApp(app_id))
- return false;
- // Do not handle drag if an operation for another app is already in progress,
- // or the cursor is not inside the shelf bounds. This could happen if mouse /
- // touch operations overlap.
- return !app_id.empty() &&
- (drag_and_drop_shelf_id_.IsNull() ||
- drag_and_drop_shelf_id_.app_id == app_id) &&
- GetBoundsInScreen().Contains(location_in_screen);
- }
- bool ShelfView::StartDrag(const std::string& app_id,
- const gfx::Point& location_in_screen,
- const gfx::Rect& drag_icon_bounds_in_screen) {
- // Don't start a drag if another one is in progress.
- if (!drag_and_drop_shelf_id_.IsNull())
- return false;
- if (!ShouldHandleDrag(app_id, location_in_screen))
- return false;
- DCHECK(!is_active_drag_and_drop_host_);
- is_active_drag_and_drop_host_ = true;
- // If the AppsGridView (which was dispatching this event) was opened by our
- // button, ShelfView dragging operations are locked and we have to unlock.
- CancelDrag(absl::nullopt);
- 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.
- if (!model_->IsAppPinned(app_id)) {
- ShelfModel::ScopedUserTriggeredMutation user_triggered(model_);
- if (model_->ItemIndexByAppID(app_id) >= 0) {
- model_->PinExistingItemWithID(app_id);
- } else {
- model_->AddAndPinAppWithFactoryConstructedDelegate(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.
- const gfx::Point start_point_in_screen =
- drag_and_drop_view->GetBoundsInScreen().CenterPoint();
- gfx::Point pt = start_point_in_screen;
- views::View::ConvertPointFromScreen(drag_and_drop_view, &pt);
- gfx::Point point_in_root = start_point_in_screen;
- wm::ConvertPointFromScreen(window_util::GetRootWindowAt(location_in_screen),
- &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, drag_icon_bounds_in_screen);
- return true;
- }
- bool ShelfView::Drag(const gfx::Point& location_in_screen,
- const gfx::Rect& drag_icon_bounds_in_screen) {
- if (drag_and_drop_shelf_id_.IsNull() ||
- !GetBoundsInScreen().Contains(location_in_screen))
- return false;
- drag_icon_bounds_in_screen_ = drag_icon_bounds_in_screen;
- gfx::Point pt = location_in_screen;
- 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;
- wm::ConvertPointFromScreen(window_util::GetRootWindowAt(location_in_screen),
- &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,
- std::unique_ptr<AppDragIconProxy> icon_proxy) {
- drag_scroll_dir_ = 0;
- scrolling_timer_.Stop();
- speed_up_drag_scrolling_.Stop();
- if (drag_and_drop_shelf_id_.IsNull()) {
- is_active_drag_and_drop_host_ = false;
- return;
- }
- drag_icon_proxy_ = std::move(icon_proxy);
- 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) {
- ShelfModel::ScopedUserTriggeredMutation user_triggered(model_);
- model_->UnpinAppWithID(drag_and_drop_shelf_id_.app_id);
- } else if (drag_and_drop_view) {
- std::unique_ptr<gfx::AnimationDelegate> animation_delegate;
- // Resets the dragged view's opacity at the end of drag. Otherwise, if
- // the app is already pinned on shelf before drag starts, the dragged view
- // will be invisible when drag ends.
- animation_delegate =
- std::make_unique<StartFadeAnimationDelegate>(this, 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();
- bounds_animator_->SetAnimationDelegate(drag_and_drop_view,
- std::move(animation_delegate));
- } else {
- drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
- }
- }
- drag_icon_bounds_in_screen_ = gfx::Rect();
- drag_and_drop_shelf_id_ = ShelfID();
- is_active_drag_and_drop_host_ = false;
- }
- void ShelfView::SwapButtons(views::View* button_to_swap, bool with_next) {
- if (!button_to_swap)
- return;
- // Find the index of the button to swap in the view model.
- size_t src_index = static_cast<size_t>(-1);
- for (size_t i = 0; i < view_model_->view_size(); ++i) {
- View* view = view_model_->view_at(i);
- if (view == button_to_swap) {
- src_index = i;
- break;
- }
- }
- // Swapping items in the model is sufficient, everything will then be
- // reflected in the views.
- if (model_->Swap(src_index, with_next)) {
- AnimateToIdealBounds();
- const ShelfItem src_item = model_->items()[src_index];
- const ShelfItem dst_item =
- model_->items()[src_index + (with_next ? 1 : -1)];
- AnnounceSwapEvent(src_item, dst_item);
- }
- }
- void ShelfView::PointerPressedOnButton(views::View* view,
- Pointer pointer,
- const ui::LocatedEvent& event) {
- if (drag_view_)
- return;
- if (IsShowingMenu())
- shelf_menu_model_adapter_->Cancel();
- auto index = view_model_->GetIndexOfView(view);
- if (!index.has_value() || view_model_->view_size() < 1)
- return; // View is being deleted, ignore request.
- // Reset drag icon proxy from previous drag (which could be set if the drop
- // animation is still in progress), as drag icon proxy is not expected to be
- // reused after it starts animating out.
- drag_icon_proxy_.reset();
- // 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(ShelfAppButton::kViewClassName, view->GetClassName());
- drag_view_ = static_cast<ShelfAppButton*>(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(const 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(const views::View* view,
- Pointer pointer,
- bool canceled) {
- drag_scroll_dir_ = 0;
- scrolling_timer_.Stop();
- speed_up_drag_scrolling_.Stop();
- is_repost_event_on_same_item_ = false;
- if (canceled) {
- CancelDrag(absl::nullopt);
- } else if (drag_pointer_ == pointer) {
- FinalizeRipOffDrag(false);
- drag_pointer_ = NONE;
- // Check if the pin status of |drag_view_| should be changed when
- // |drag_view_| is dragged over the separator. Do nothing if |drag_view_| is
- // already handled in FinalizedRipOffDrag.
- if (drag_view_) {
- if (ShouldUpdateDraggedViewPinStatus(
- view_model_->GetIndexOfView(view).value())) {
- const std::string drag_app_id = ShelfItemForView(drag_view_)->id.app_id;
- ShelfModel::ScopedUserTriggeredMutation user_triggered(model_);
- if (model_->IsAppPinned(drag_app_id)) {
- model_->UnpinAppWithID(drag_app_id);
- } else {
- model_->PinExistingItemWithID(drag_app_id);
- }
- }
- }
- AnimateToIdealBounds();
- }
- if (drag_pointer_ != NONE)
- return;
- delegate_->CancelScrollForItemDrag();
- if (!drag_view_ || dragged_off_shelf_)
- drag_icon_proxy_.reset();
- if (drag_icon_proxy_) {
- const gfx::Rect drag_view_ideal_bounds = view_model_->ideal_bounds(
- view_model_->GetIndexOfView(drag_view_).value());
- gfx::Rect target_bounds_in_screen =
- drag_view_->GetIdealIconBounds(drag_view_ideal_bounds.size(),
- /*icon_scale=*/1.0f);
- target_bounds_in_screen.Offset(drag_view_ideal_bounds.x(),
- drag_view_ideal_bounds.y());
- target_bounds_in_screen = GetMirroredRect(target_bounds_in_screen);
- views::View::ConvertRectToScreen(this, &target_bounds_in_screen);
- if (!delegate_->AreBoundsWithinVisibleSpace(target_bounds_in_screen)) {
- drag_icon_proxy_.reset();
- drag_view_->layer()->SetOpacity(1.0f);
- } else {
- drag_icon_proxy_->AnimateToBoundsAndCloseWidget(
- target_bounds_in_screen,
- base::BindOnce(&ShelfView::OnDragIconProxyAnimatedOut,
- base::Unretained(this),
- std::make_unique<ViewOpacityResetter>(drag_view_)));
- }
- }
- // If the drag pointer is NONE, no drag operation is going on and the
- // |drag_view_| can be released.
- drag_view_ = nullptr;
- drag_view_relative_to_ideal_bounds_ = RelativePosition::kNotAvailable;
- RemoveGhostView();
- }
- void ShelfView::OnDragIconProxyAnimatedOut(
- std::unique_ptr<ViewOpacityResetter> opacity_resetter) {
- opacity_resetter->Run();
- drag_icon_proxy_.reset();
- }
- void ShelfView::LayoutToIdealBounds() {
- if (bounds_animator_->IsAnimating()) {
- AnimateToIdealBounds();
- return;
- }
- CalculateIdealBounds();
- views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
- UpdateVisibleShelfItemBoundsUnion();
- }
- bool ShelfView::IsItemPinned(const ShelfItem& item) const {
- return IsPinnedShelfItemType(item.type);
- }
- bool ShelfView::IsItemVisible(const ShelfItem& item) const {
- return (IsItemPinned(item) || item.is_on_active_desk) &&
- !(model_->in_shelf_party() && item.status == STATUS_CLOSED);
- }
- void ShelfView::OnTabletModeChanged() {
- // The layout change will happen as part of shelf config update.
- }
- void ShelfView::AnimateToIdealBounds() {
- CalculateIdealBounds();
- move_animation_tracker_.emplace(
- GetWidget()->GetCompositor()->RequestNewThroughputTracker());
- move_animation_tracker_->Start(metrics_util::ForSmoothness(
- base::BindRepeating(&ReportMoveAnimationSmoothness)));
- for (size_t 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.
- view->SetBorder(nullptr);
- }
- UpdateVisibleShelfItemBoundsUnion();
- }
- void ShelfView::FadeIn(views::View* view) {
- view->SetVisible(true);
- view->layer()->SetOpacity(0);
- ui::ScopedLayerAnimationSettings fade_in_animation_settings(
- view->layer()->GetAnimator());
- fade_in_animation_settings.SetTweenType(gfx::Tween::EASE_OUT);
- fade_in_animation_settings.SetPreemptionStrategy(
- ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
- fade_in_animation_settings.AddObserver(fade_in_animation_delegate_.get());
- ui::AnimationThroughputReporter reporter(
- fade_in_animation_settings.GetAnimator(),
- metrics_util::ForSmoothness(
- base::BindRepeating(&ReportFadeInAnimationSmoothness)));
- view->layer()->SetOpacity(1.f);
- }
- 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_);
- drag_scroll_dir_ = 0;
- if (!start_drag_index_.has_value()) {
- CancelDrag(absl::nullopt);
- return;
- }
- // Cancel in-flight request for app item context menu model (made when app
- // context menu is requested), to prevent the pending callback from showing
- // a context menu just after drag starts.
- if (!context_menu_callback_.IsCancelled()) {
- GetShelfAppButton(item_awaiting_response_)
- ->OnContextMenuModelRequestCanceled();
- ResetActiveMenuModelRequest();
- }
- // Move the view to the front so that it appears on top of other views.
- ReorderChildView(drag_view_, children().size());
- bounds_animator_->StopAnimatingView(drag_view_);
- drag_view_->OnDragStarted(&event);
- // Drag icon proxy from previous drag may be around if the icon is still
- // animating to the final position. Reset it here to cancel the animation.
- drag_icon_proxy_.reset();
- delegate_->CancelScrollForItemDrag();
- drag_view_->layer()->SetOpacity(0.0f);
- if (!is_active_drag_and_drop_host_) {
- aura::Window* root_window = GetWidget()->GetNativeWindow()->GetRootWindow();
- gfx::Point screen_location = event.root_location();
- ::wm::ConvertPointToScreen(root_window, &screen_location);
- // Scale up the icon only if the button is not considered as dragged and
- // scaled up in ShelfAppButton.
- float scale_factor = (drag_view_->state() & ShelfAppButton::STATE_DRAGGING)
- ? 1.0f
- : kDragAndDropProxyScale;
- drag_icon_proxy_ = std::make_unique<AppDragIconProxy>(
- root_window, drag_view_->GetIconImage(), screen_location,
- gfx::Vector2d(), scale_factor, /*use_blurred_background=*/false);
- if (pointer == MOUSE) {
- haptics_util::PlayHapticTouchpadEffect(
- ui::HapticTouchpadEffect::kTick,
- ui::HapticTouchpadEffectStrength::kMedium);
- }
- }
- }
- void ShelfView::ContinueDrag(const ui::LocatedEvent& event) {
- DCHECK(dragging());
- DCHECK(drag_view_);
- const auto index = view_model_->GetIndexOfView(drag_view_);
- DCHECK(index.has_value());
- const bool dragged_off_shelf_before = dragged_off_shelf_;
- // Handle rip off functionality if this is not a drag and drop host operation
- // and not the app list item.
- if (drag_and_drop_shelf_id_.IsNull() &&
- RemovableByRipOff(index.value()) != NOT_REMOVABLE) {
- HandleRipOffDrag(event);
- // Check if the item got ripped off the shelf - if it did we are done.
- if (dragged_off_shelf_) {
- drag_scroll_dir_ = 0;
- scrolling_timer_.Stop();
- speed_up_drag_scrolling_.Stop();
- if (!dragged_off_shelf_before)
- model_->OnItemRippedOff();
- return;
- }
- }
- // Calculates the drag point in screen before MoveDragViewTo is called.
- gfx::Point drag_point_in_screen(event.location());
- ConvertPointToScreen(drag_view_, &drag_point_in_screen);
- gfx::Point drag_point(event.location());
- ConvertPointToTarget(drag_view_, this, &drag_point);
- MoveDragViewTo(shelf_->PrimaryAxisValue(drag_point.x() - drag_origin_.x(),
- drag_point.y() - drag_origin_.y()));
- if (drag_icon_proxy_)
- drag_icon_proxy_->UpdatePosition(drag_point_in_screen);
- // If drag_icon_proxy_ is available, get its item bounds, otherwise (in case
- // of an ApplicationDragAndDropHost drag), last drag icon bounds are cached in
- // `drag_icon_bounds_in_screen_`.
- const gfx::Rect drag_icon_bounds_in_screen =
- drag_icon_proxy_ ? drag_icon_proxy_->GetBoundsInScreen()
- : drag_icon_bounds_in_screen_;
- delegate_->ScheduleScrollForItemDragIfNeeded(drag_icon_bounds_in_screen);
- if (dragged_off_shelf_before) {
- model_->OnItemReturnedFromRipOff(
- static_cast<int>(view_model_->GetIndexOfView(drag_view_).value()));
- }
- }
- void ShelfView::MoveDragViewTo(int primary_axis_coordinate) {
- const size_t current_item_index =
- view_model_->GetIndexOfView(drag_view_).value();
- const std::pair<size_t, size_t> indices(GetDragRange(current_item_index));
- if (shelf_->IsHorizontalAlignment()) {
- int x = GetMirroredXWithWidthInView(primary_axis_coordinate,
- drag_view_->width());
- x = std::max(view_model_->ideal_bounds(indices.first).x(), x);
- x = std::min(view_model_->ideal_bounds(indices.second).right() -
- view_model_->ideal_bounds(current_item_index).width(),
- x);
- if (drag_view_->x() != x)
- drag_view_->SetX(x);
- } else {
- int y = std::max(view_model_->ideal_bounds(indices.first).y(),
- primary_axis_coordinate);
- y = std::min(view_model_->ideal_bounds(indices.second).bottom() -
- view_model_->ideal_bounds(current_item_index).height(),
- y);
- if (drag_view_->y() != y)
- drag_view_->SetY(y);
- }
- size_t target_index = views::ViewModelUtils::DetermineMoveIndex(
- *view_model_, drag_view_, shelf_->IsHorizontalAlignment(),
- drag_view_->x(), drag_view_->y());
- target_index = base::clamp(target_index, indices.first, indices.second);
- // Check the relative position of |drag_view_| and its ideal bounds if it can
- // be dragged across the separator to pin or unpin.
- if (CanDragAcrossSeparator(drag_view_)) {
- // Compare the center points of |drag_view_| and its ideal bounds to
- // determine whether the separator should be moved to the left or right by
- // using |drag_view_relative_to_ideal_bounds_|. The actual position will
- // be updated in CalculateIdealBounds.
- gfx::Point drag_view_center = drag_view_->bounds().CenterPoint();
- int drag_view_position =
- shelf()->PrimaryAxisValue(drag_view_center.x(), drag_view_center.y());
- gfx::Point ideal_bound_center =
- view_model_->ideal_bounds(target_index).CenterPoint();
- int ideal_bound_position = shelf()->PrimaryAxisValue(
- ideal_bound_center.x(), ideal_bound_center.y());
- drag_view_relative_to_ideal_bounds_ =
- drag_view_position < ideal_bound_position ? RelativePosition::kLeft
- : RelativePosition::kRight;
- if (target_index == current_item_index) {
- AnimateToIdealBounds();
- NotifyAccessibilityEvent(ax::mojom::Event::kChildrenChanged,
- true /* send_native_event */);
- }
- }
- if (target_index == current_item_index)
- return;
- // Change the model if the dragged item index is changed, the ShelfItemMoved()
- // callback will handle the |view_model_| update.
- model_->Move(current_item_index, target_index);
- bounds_animator_->StopAnimatingView(drag_view_);
- }
- void ShelfView::HandleRipOffDrag(const ui::LocatedEvent& event) {
- auto current_index = view_model_->GetIndexOfView(drag_view_);
- DCHECK(current_index.has_value());
- std::string dragged_app_id = model_->items()[current_index.value()].id.app_id;
- aura::Window* root_window = GetWidget()->GetNativeWindow()->GetRootWindow();
- gfx::Point screen_location = event.root_location();
- ::wm::ConvertPointToScreen(root_window, &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 (!is_active_drag_and_drop_host_) {
- drag_icon_proxy_ = std::make_unique<AppDragIconProxy>(
- root_window, drag_view_->GetIconImage(), screen_location,
- /*cursor_offset_from_center=*/gfx::Vector2d(),
- /*scale_factor=*/1.0f,
- /*use_blurred_background=*/false);
- }
- // Re-insert the item and return simply false since the caller will handle
- // the move as in any normal case.
- dragged_off_shelf_ = false;
- // After re-insertion, trigger an animation to ideal bounds to show the
- // ghost view.
- AnimateToIdealBounds();
- return;
- }
- drag_icon_proxy_->UpdatePosition(screen_location);
- return;
- }
- // Mark the item as dragged off the shelf if the drag distance exceeds
- // `rip_off_distance`.
- int rip_off_distance =
- ShelfConfig::Get()->shelf_size() * kRipOffDistanceFactor;
- int delta = CalculateShelfDistance(screen_location);
- bool dragged_off_shelf = delta > rip_off_distance;
- if (dragged_off_shelf) {
- if (!is_active_drag_and_drop_host_) {
- // Create a new, scaled up drag icon proxy when the item is dragged off
- // shelf - keep cursor position consistent with the host provided icon.
- const gfx::Point center = drag_view_->GetLocalBounds().CenterPoint();
- const gfx::Vector2d cursor_offset_from_center = drag_origin_ - center;
- drag_icon_proxy_ = std::make_unique<AppDragIconProxy>(
- root_window, drag_view_->GetIconImage(), screen_location,
- cursor_offset_from_center, /*scale_factor=*/1.0f,
- /*use_blurred_background=*/false);
- delegate_->CancelScrollForItemDrag();
- }
- dragged_off_shelf_ = true;
- RemoveGhostView();
- if (RemovableByRipOff(current_index.value()) == REMOVABLE) {
- // Move the item to the back and hide it. ShelfItemMoved() callback will
- // handle the |view_model_| update and call AnimateToIdealBounds().
- if (current_index.value() !=
- static_cast<size_t>(model_->item_count() - 1)) {
- model_->Move(current_index.value(), model_->item_count() - 1);
- }
- // Make the item partially disappear to show that it will get removed if
- // dropped.
- drag_icon_proxy_->SetOpacity(kDraggedImageOpacity);
- }
- }
- }
- 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_);
- DCHECK(drag_icon_proxy_);
- delegate_->CancelScrollForItemDrag();
- auto current_index = view_model_->GetIndexOfView(drag_view_);
- // If the view isn't part of the model anymore, 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.has_value()) {
- drag_icon_proxy_.reset();
- 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 (RemovableByRipOff(current_index.value()) != 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);
- ShelfModel::ScopedUserTriggeredMutation user_triggered(model_);
- model_->UnpinAppWithID(model_->items()[current_index.value()].id.app_id);
- }
- }
- if (cancel || snap_back) {
- if (!cancelling_drag_model_changed_) {
- // Only do something if the change did not come through a model change.
- gfx::Rect drag_bounds = drag_icon_proxy_->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(ShelfAppButton::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.value(), start_drag_index_.value());
- AnimateToIdealBounds();
- }
- drag_view_->layer()->SetOpacity(1.0f);
- model_->OnItemReturnedFromRipOff(model_->item_count() - 1);
- }
- drag_icon_proxy_.reset();
- }
- ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) const {
- DCHECK(index >= 0 && index < model_->item_count());
- ShelfItemType type = model_->items()[index].type;
- if (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;
- // Pinned standalone browser apps should not be removable.
- if (IsStandaloneBrowser(app_id))
- return DRAGGABLE;
- return (type == TYPE_PINNED_APP && model_->IsAppPinned(app_id)) ? REMOVABLE
- : DRAGGABLE;
- }
- bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
- if (IsPinnedShelfItemType(typea) && IsPinnedShelfItemType(typeb))
- return true;
- if (typea == TYPE_UNDEFINED || typeb == TYPE_UNDEFINED) {
- NOTREACHED() << "ShelfItemType must be set.";
- return false;
- }
- // Running app or dialog.
- return typea == typeb;
- }
- bool ShelfView::ShouldFocusOut(bool reverse, views::View* button) {
- // The logic here seems backwards, but is actually correct. For instance if
- // the ShelfView's internal focus cycling logic attemmpts to focus the first
- // child after hitting Tab, we intercept that and instead, advance through
- // to the status area.
- return (reverse && button == FindLastFocusableChild()) ||
- (!reverse && button == FindFirstFocusableChild());
- }
- std::pair<size_t, size_t> ShelfView::GetDragRange(size_t index) {
- DCHECK(base::Contains(visible_views_indices_, index));
- const ShelfItem& dragged_item = model_->items()[index];
- // If |drag_view_| is allowed to be dragged across the separator, return the
- // first and the last index of the |visible_views_indices_|.
- if (CanDragAcrossSeparator(drag_view_)) {
- return std::make_pair(visible_views_indices_[0],
- visible_views_indices_.back());
- }
- absl::optional<size_t> first = absl::nullopt;
- absl::optional<size_t> last = absl::nullopt;
- for (size_t i : visible_views_indices_) {
- if (SameDragType(model_->items()[i].type, dragged_item.type)) {
- if (!first.has_value())
- first = i;
- last = i;
- } else if (first.has_value()) {
- break;
- }
- }
- DCHECK(first.has_value());
- DCHECK(last.has_value());
- // TODO(afakhry): Consider changing this when taking into account inactive
- // desks.
- return std::make_pair(first.value(), last.value());
- }
- bool ShelfView::ShouldUpdateDraggedViewPinStatus(size_t dragged_view_index) {
- if (!features::IsDragUnpinnedAppToPinEnabled())
- return false;
- DCHECK(base::Contains(visible_views_indices_, dragged_view_index));
- bool is_moved_item_pinned =
- IsPinnedShelfItemType(model_->items()[dragged_view_index].type);
- if (!separator_index_.has_value()) {
- // If there is no |separator_index_|, all the apps in shelf are expected to
- // have the same pinned status.
- for (auto index : visible_views_indices_) {
- if (index != dragged_view_index) {
- // Return true if the pin status of the moved item is different from
- // others.
- return is_moved_item_pinned !=
- IsPinnedShelfItemType(model_->items()[index].type);
- }
- }
- return false;
- }
- // If the separator is shown, check whether the pin status of dragged item
- // matches the pin status implied by the dragged view position relative to the
- // separator.
- bool should_pinned_by_position =
- dragged_view_index <= separator_index_.value();
- return should_pinned_by_position != is_moved_item_pinned;
- }
- bool ShelfView::CanDragAcrossSeparator(views::View* drag_view) const {
- if (!features::IsDragUnpinnedAppToPinEnabled())
- return false;
- DCHECK(drag_view);
- // The dragged item is not allowed to be unpinned if |drag_view| is pinned by
- // policy, dragged from app list, or its item type is TYPE_BROWSER_SHORTCUT
- // or TYPE_UNPINNED_BROWSER_SHORTCUT.
- // Therefore, the |drag_view| can not be dragged across the separator.
- bool can_change_pin_state =
- ShelfItemForView(drag_view)->type == TYPE_PINNED_APP ||
- ShelfItemForView(drag_view)->type == TYPE_APP;
- // Note that |drag_and_drop_shelf_id_| is set only when the current drag view
- // is from app list, which can not be dragged to the unpinned app side.
- return !ShelfItemForView(drag_view)->pinned_by_policy &&
- drag_and_drop_shelf_id_ == ShelfID() && can_change_pin_state;
- }
- void ShelfView::OnFadeInAnimationEnded() {
- // Call PreferredSizeChanged() to notify container to re-layout at the end
- // of fade-in animation.
- PreferredSizeChanged();
- }
- void ShelfView::OnFadeOutAnimationEnded() {
- if (fade_out_animation_tracker_) {
- fade_out_animation_tracker_->Stop();
- fade_out_animation_tracker_.reset();
- }
- // Call PreferredSizeChanged() to notify container to re-layout at the end
- // of removal animation.
- PreferredSizeChanged();
- AnimateToIdealBounds();
- }
- gfx::Rect ShelfView::GetMenuAnchorRect(const views::View& source,
- const gfx::Point& location,
- bool context_menu) const {
- // Application menus for items are anchored on the icon bounds.
- if (ShelfItemForView(&source) || !context_menu)
- return source.GetBoundsInScreen();
- gfx::Rect shelf_bounds_in_screen;
- if (ShelfConfig::Get()->is_in_app() && IsTabletModeEnabled()) {
- // Use the shelf widget background as the menu anchor point in tablet mode
- // and in app.
- ShelfWidget* shelf_widget = shelf_->shelf_widget();
- shelf_bounds_in_screen = shelf_widget->GetOpaqueBackground()->bounds();
- const gfx::Rect widget_bounds =
- shelf_widget->GetRootView()->GetBoundsInScreen();
- shelf_bounds_in_screen.Offset(widget_bounds.x(), widget_bounds.y());
- } else {
- shelf_bounds_in_screen = GetBoundsInScreen();
- }
- gfx::Point origin;
- switch (shelf_->alignment()) {
- case ShelfAlignment::kBottom:
- case ShelfAlignment::kBottomLocked:
- origin = gfx::Point(location.x(), shelf_bounds_in_screen.y());
- break;
- case ShelfAlignment::kLeft:
- origin = gfx::Point(shelf_bounds_in_screen.right(), location.y());
- break;
- case ShelfAlignment::kRight:
- origin = gfx::Point(shelf_bounds_in_screen.x(), location.y());
- break;
- }
- return gfx::Rect(origin, gfx::Size());
- }
- void ShelfView::AnnounceShelfAlignment() {
- std::u16string announcement;
- switch (shelf_->alignment()) {
- case ShelfAlignment::kBottom:
- case ShelfAlignment::kBottomLocked:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_ALIGNMENT_BOTTOM);
- break;
- case ShelfAlignment::kLeft:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_ALIGNMENT_LEFT);
- break;
- case ShelfAlignment::kRight:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_ALIGNMENT_RIGHT);
- break;
- }
- announcement_view_->GetViewAccessibility().OverrideName(announcement);
- announcement_view_->NotifyAccessibilityEvent(ax::mojom::Event::kAlert,
- /*send_native_event=*/true);
- }
- bool ShelfView::IsAnimating() const {
- return bounds_animator_->IsAnimating();
- }
- gfx::Rect ShelfView::GetDragIconBoundsInScreenForTest() const {
- if (!drag_icon_proxy_)
- return gfx::Rect();
- return drag_icon_proxy_->GetBoundsInScreen();
- }
- void ShelfView::AnnounceShelfAutohideBehavior() {
- std::u16string announcement;
- switch (shelf_->auto_hide_behavior()) {
- case ShelfAutoHideBehavior::kAlways:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_STATE_AUTO_HIDE);
- break;
- case ShelfAutoHideBehavior::kNever:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_STATE_ALWAYS_SHOWN);
- break;
- case ShelfAutoHideBehavior::kAlwaysHidden:
- announcement = l10n_util::GetStringUTF16(IDS_SHELF_STATE_ALWAYS_HIDDEN);
- break;
- }
- announcement_view_->GetViewAccessibility().OverrideName(announcement);
- announcement_view_->NotifyAccessibilityEvent(ax::mojom::Event::kAlert,
- /*send_native_event=*/true);
- }
- void ShelfView::AnnouncePinUnpinEvent(const ShelfItem& item, bool pinned) {
- std::u16string item_title =
- item.title.empty()
- ? l10n_util::GetStringUTF16(IDS_SHELF_ITEM_GENERIC_NAME)
- : item.title;
- std::u16string announcement = l10n_util::GetStringFUTF16(
- pinned ? IDS_SHELF_ITEM_WAS_PINNED : IDS_SHELF_ITEM_WAS_UNPINNED,
- item_title);
- announcement_view_->GetViewAccessibility().OverrideName(announcement);
- announcement_view_->NotifyAccessibilityEvent(ax::mojom::Event::kAlert,
- /*send_native_event=*/true);
- }
- void ShelfView::AnnounceSwapEvent(const ShelfItem& first_item,
- const ShelfItem& second_item) {
- std::u16string first_item_title =
- first_item.title.empty()
- ? l10n_util::GetStringUTF16(IDS_SHELF_ITEM_GENERIC_NAME)
- : first_item.title;
- std::u16string second_item_title =
- second_item.title.empty()
- ? l10n_util::GetStringUTF16(IDS_SHELF_ITEM_GENERIC_NAME)
- : second_item.title;
- std::u16string announcement = l10n_util::GetStringFUTF16(
- IDS_SHELF_ITEMS_WERE_SWAPPED, first_item_title, second_item_title);
- announcement_view_->GetViewAccessibility().OverrideName(announcement);
- announcement_view_->NotifyAccessibilityEvent(ax::mojom::Event::kAlert,
- /*send_native_event=*/true);
- }
- gfx::Rect ShelfView::GetBoundsForDragInsertInScreen() {
- const ScrollableShelfView* scrollable_shelf_view =
- shelf_->hotseat_widget()->scrollable_shelf_view();
- gfx::Rect bounds = scrollable_shelf_view->visible_space();
- views::View::ConvertRectToScreen(scrollable_shelf_view, &bounds);
- return bounds;
- }
- absl::optional<size_t> ShelfView::CancelDrag(
- absl::optional<size_t> modified_index) {
- drag_scroll_dir_ = 0;
- scrolling_timer_.Stop();
- speed_up_drag_scrolling_.Stop();
- FinalizeRipOffDrag(true);
- delegate_->CancelScrollForItemDrag();
- drag_icon_proxy_.reset();
- if (!drag_view_)
- return modified_index;
- bool was_dragging = dragging();
- auto 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.has_value() && !at_end)
- ? view_model_->view_at(modified_index.value())
- : nullptr;
- model_->Move(drag_view_index.value(), start_drag_index_.value());
- // 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)
- : absl::nullopt;
- }
- void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
- if (!ShouldHandleGestures(*event))
- return;
- if (HandleGestureEvent(event))
- event->StopPropagation();
- }
- void ShelfView::ShelfItemAdded(int model_index) {
- // ShelfView must keep view_model_ in sync with ShelfModel::items_ as its very
- // first response to ShelfModel changes. Failure to do so can result in UaF in
- // methods like ShelfView::ShelfItemForView, which can be implicitly called by
- // other classes. See https://crbug.com/1238959 for more details.
- const ShelfItem& item(model_->items()[model_index]);
- views::View* view = CreateViewForItem(item);
- {
- base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
- true);
- model_index = static_cast<int>(CancelDrag(model_index).value());
- }
- view_model_->Add(view, static_cast<size_t>(model_index));
- // If |item| is pinned and the mutation is user-triggered, report the pinning
- // action for accessibility and UMA. Do it now, because if |item| is hidden
- // then we will soon bail out but we still want to report the pinning action.
- if (model_->is_current_mutation_user_triggered() &&
- item.type == TYPE_PINNED_APP) {
- AnnouncePinUnpinEvent(item, /*pinned=*/true);
- RecordPinUnpinUserAction(/*pinned=*/true);
- }
- // Add child view so it has the same ordering as in the |view_model_|.
- // Note: No need to call UpdateShelfItemViewsVisibility() here directly, since
- // it will be called by ScrollableShelfView::ViewHierarchyChanged() as a
- // result of the below call.
- AddChildViewAt(view, model_index);
- if (!IsItemVisible(item))
- return;
- // 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);
- // 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).
- CalculateIdealBounds();
- view->SetBoundsRect(
- view_model_->ideal_bounds(static_cast<size_t>(model_index)));
- if (model_->is_current_mutation_user_triggered() &&
- drag_and_drop_shelf_id_ != item.id) {
- view->ScrollViewToVisible();
- }
- // 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();
- DCHECK_LE(static_cast<size_t>(model_index), visible_views_indices_.back());
- bounds_animator_->SetAnimationDelegate(
- view, std::unique_ptr<gfx::AnimationDelegate>(
- new StartFadeAnimationDelegate(this, view)));
- }
- void ShelfView::ShelfItemRemoved(int model_index, const ShelfItem& old_item) {
- // ShelfView must keep view_model_ in sync with ShelfModel::items_ as its very
- // first response to ShelfModel changes. Failure to do so can result in UaF in
- // methods like ShelfView::ShelfItemForView, which can be implicitly called by
- // other classes. See https://crbug.com/1238959 for more details.
- //
- // If std::move is not called on |view|, |view| will be deleted once out of
- // scope.
- std::unique_ptr<views::View> view(view_model_->view_at(model_index));
- shelf_button_delegate_->OnButtonWillBeRemoved();
- view_model_->Remove(model_index);
- if (old_item.id == context_menu_id_ && shelf_menu_model_adapter_)
- shelf_menu_model_adapter_->Cancel();
- if (old_item.id == item_awaiting_response_)
- ResetActiveMenuModelRequest();
- {
- base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
- true);
- CancelDrag(absl::nullopt);
- }
- if (view.get() == shelf_->tooltip()->GetCurrentAnchorView())
- shelf_->tooltip()->Close();
- if (view->GetVisible() && view->layer()->opacity() > 0.0f) {
- UpdateShelfItemViewsVisibility();
- // There could be multiple fade out animations running. Only start
- // tracking for the first one.
- if (!fade_out_animation_tracker_) {
- fade_out_animation_tracker_.emplace(
- GetWidget()->GetCompositor()->RequestNewThroughputTracker());
- fade_out_animation_tracker_->Start(metrics_util::ForSmoothness(
- base::BindRepeating(&ReportFadeOutAnimationSmoothness)));
- }
- // 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.get(), view->bounds());
- auto* const view_ptr = view.get();
- bounds_animator_->SetAnimationDelegate(
- view_ptr,
- std::make_unique<FadeOutAnimationDelegate>(this, std::move(view)));
- } else {
- // Ensures that |view| is not used after destruction.
- StopAnimatingViewIfAny(view.get());
- // Removes |view| to trigger ViewHierarchyChanged function in the parent
- // view if any.
- view.reset();
- // If there is no fade out animation, notify the parent view of the
- // changed size before bounds animations start.
- PreferredSizeChanged();
- // 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 (model_->is_current_mutation_user_triggered() &&
- old_item.type == TYPE_PINNED_APP) {
- AnnouncePinUnpinEvent(old_item, /*pinned=*/false);
- RecordPinUnpinUserAction(/*pinned=*/false);
- }
- }
- void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
- // Bail if the view and shelf sizes do not match. ShelfItemChanged may be
- // called here before ShelfItemAdded, due to ChromeShelfController's
- // item initialization, which calls SetItem during ShelfItemAdded.
- if (model_->items().size() != view_model_->view_size())
- return;
- const ShelfItem& item = model_->items()[model_index];
- // If there's a change in the item's active desk, perform the update at the
- // end of this function in order to guarantee that both |model_| and
- // |view_model_| are consistent if there are other changes in the item.
- base::ScopedClosureRunner run_at_scope_exit;
- if (old_item.is_on_active_desk != item.is_on_active_desk) {
- run_at_scope_exit.ReplaceClosure(base::BindOnce(
- &ShelfView::ShelfItemsUpdatedForDeskChange, base::Unretained(this)));
- }
- if (old_item.type != item.type) {
- // Type changed, swap the views.
- model_index = static_cast<int>(CancelDrag(model_index).value());
- 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);
- // The view must be added to the |view_model_| before it's added as a child
- // so that the model is consistent when UpdateShelfItemViewsVisibility() is
- // called as a result the hierarchy changes caused by AddChildView(). See
- // ScrollableShelfView::ViewHierarchyChanged().
- view_model_->Add(new_view, model_index);
- AddChildView(new_view);
- view_model_->set_ideal_bounds(model_index, old_ideal_bounds);
- bounds_animator_->StopAnimatingView(new_view);
- new_view->SetBoundsRect(old_view->bounds());
- bounds_animator_->AnimateViewTo(new_view, old_ideal_bounds);
- // If an item is being pinned or unpinned, show the new status of the
- // shelf immediately so that the separator gets drawn as needed.
- if (old_item.type == TYPE_PINNED_APP || item.type == TYPE_PINNED_APP) {
- if (model_->is_current_mutation_user_triggered()) {
- AnnouncePinUnpinEvent(old_item, item.type == TYPE_PINNED_APP);
- RecordPinUnpinUserAction(item.type == TYPE_PINNED_APP);
- }
- AnimateToIdealBounds();
- }
- return;
- }
- views::View* view = view_model_->view_at(model_index);
- switch (item.type) {
- case TYPE_PINNED_APP:
- case TYPE_BROWSER_SHORTCUT:
- case TYPE_APP:
- case TYPE_UNPINNED_BROWSER_SHORTCUT:
- case TYPE_DIALOG: {
- CHECK_EQ(ShelfAppButton::kViewClassName, view->GetClassName());
- ShelfAppButton* button = static_cast<ShelfAppButton*>(view);
- button->ReflectItemStatus(item);
- button->SetImage(item.image);
- button->SetNotificationBadgeColor(item.notification_badge_color);
- button->SchedulePaint();
- break;
- }
- case TYPE_UNDEFINED:
- break;
- }
- if (model_->in_shelf_party())
- HandleShelfParty();
- }
- void ShelfView::ShelfItemsUpdatedForDeskChange() {
- DCHECK(features::IsPerDeskShelfEnabled());
- // The order here matters, since switching/removing desks, or moving windows
- // between desks will affect shelf items' visibility, we need to update the
- // visibility of the views first before we layout.
- UpdateShelfItemViewsVisibility();
- // Signal to the parent ScrollableShelfView so that it can recenter the items
- // after their visibility have been updated (via
- // `UpdateAvailableSpaceAndScroll()`).
- PreferredSizeChanged();
- LayoutToIdealBounds();
- }
- void ShelfView::ShelfItemMoved(int start_index, int target_index) {
- view_model_->Move(start_index, target_index);
- // Reorder the child view to be in the same order as in the |view_model_|.
- ReorderChildView(view_model_->view_at(target_index), target_index);
- NotifyAccessibilityEvent(ax::mojom::Event::kChildrenChanged,
- true /* send_native_event */);
- // 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) {
- if (id == context_menu_id_ && shelf_menu_model_adapter_)
- shelf_menu_model_adapter_->Cancel();
- }
- void ShelfView::ShelfItemStatusChanged(const ShelfID& id) {
- scoped_display_for_new_windows_.reset();
- int index = model_->ItemIndexByID(id);
- if (index < 0)
- return;
- const ShelfItem item = model_->items()[index];
- ShelfAppButton* button = GetShelfAppButton(id);
- button->ReflectItemStatus(item);
- button->SchedulePaint();
- if (model_->in_shelf_party())
- HandleShelfParty();
- }
- void ShelfView::ShelfItemRippedOff() {
- // On the display where the drag started, there is nothing to do.
- if (dragging())
- return;
- // When a dragged item has been ripped off the shelf, it is moved to the end.
- // Now we need to hide it.
- view_model_->view_at(model_->item_count() - 1)->layer()->SetOpacity(0.f);
- }
- void ShelfView::ShelfItemReturnedFromRipOff(int index) {
- // On the display where the drag started, there is nothing to do.
- if (dragging())
- return;
- // Show the item and prevent it from animating into place from the position
- // where it was sitting with zero opacity.
- views::View* view = view_model_->view_at(index);
- const gfx::Rect bounds = bounds_animator_->GetTargetBounds(view);
- bounds_animator_->StopAnimatingView(view);
- view->SetBoundsRect(bounds);
- view->layer()->SetOpacity(1.f);
- }
- void ShelfView::ShelfPartyToggled(bool in_shelf_party) {
- HandleShelfParty();
- }
- void ShelfView::OnShelfAlignmentChanged(aura::Window* root_window,
- ShelfAlignment old_alignment) {
- LayoutToIdealBounds();
- for (size_t visible_index : visible_views_indices_)
- view_model_->view_at(visible_index)->Layout();
- AnnounceShelfAlignment();
- }
- void ShelfView::OnShelfAutoHideBehaviorChanged() {
- AnnounceShelfAutohideBehavior();
- }
- void ShelfView::AfterItemSelected(const ShelfItem& item,
- views::Button* sender,
- std::unique_ptr<ui::Event> event,
- views::InkDrop* ink_drop,
- ShelfAction action,
- ShelfItemDelegate::AppMenuItems menu_items) {
- item_awaiting_response_ = ShelfID();
- shelf_button_pressed_metric_tracker_.ButtonPressed(*event, sender, action);
- // Record AppList metric for any action considered an app launch.
- if (action == SHELF_ACTION_NEW_WINDOW_CREATED ||
- action == SHELF_ACTION_WINDOW_ACTIVATED) {
- Shell::Get()->app_list_controller()->RecordShelfAppLaunched();
- }
- // The app list handles its own ink drop effect state changes.
- if (action == SHELF_ACTION_APP_LIST_DISMISSED) {
- ink_drop->SnapToActivated();
- ink_drop->AnimateToState(views::InkDropState::HIDDEN);
- } else if (action != SHELF_ACTION_APP_LIST_SHOWN && !dragging()) {
- if (action != SHELF_ACTION_NEW_WINDOW_CREATED && menu_items.size() > 1 &&
- !dragging()) {
- // Show the app menu with 2 or more items, if no window was created. The
- // menu is not shown in case item drag started while the selection request
- // was in progress.
- ShowMenu(std::make_unique<ShelfApplicationMenuModel>(
- item.title, std::move(menu_items),
- model_->GetShelfItemDelegate(item.id)),
- sender, item.id, gfx::Point(), /*context_menu=*/false,
- ui::GetMenuSourceTypeForEvent(*event));
- shelf_->UpdateVisibilityState();
- } else {
- ink_drop->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
- }
- }
- shelf_->shelf_layout_manager()->OnShelfItemSelected(action);
- }
- void ShelfView::ShowShelfContextMenu(
- const ShelfID& shelf_id,
- const gfx::Point& point,
- views::View* source,
- ui::MenuSourceType source_type,
- std::unique_ptr<ui::SimpleMenuModel> model) {
- if (!model) {
- const int64_t display_id = GetDisplayIdForView(this);
- model = std::make_unique<ShelfContextMenuModel>(nullptr, display_id);
- }
- ShowMenu(std::move(model), source, shelf_id, point, /*context_menu=*/true,
- source_type);
- }
- void ShelfView::ShowMenu(std::unique_ptr<ui::SimpleMenuModel> menu_model,
- views::View* source,
- const ShelfID& shelf_id,
- const gfx::Point& click_point,
- bool context_menu,
- ui::MenuSourceType source_type) {
- // Delayed callbacks to show context and application menus may conflict; hide
- // the old menu before showing a new menu in that case.
- if (IsShowingMenu())
- shelf_menu_model_adapter_->Cancel();
- item_awaiting_response_ = ShelfID();
- if (menu_model->GetItemCount() == 0)
- return;
- context_menu_id_ = shelf_id;
- menu_owner_ = source;
- closing_event_time_ = base::TimeTicks();
- // NOTE: If you convert to HAS_MNEMONICS be sure to update menu building code.
- int run_types = views::MenuRunner::USE_ASH_SYS_UI_LAYOUT;
- if (context_menu) {
- run_types |=
- views::MenuRunner::CONTEXT_MENU | views::MenuRunner::FIXED_ANCHOR;
- }
- const ShelfItem* item = ShelfItemForView(source);
- if ((source_type == ui::MenuSourceType::MENU_SOURCE_MOUSE ||
- source_type == ui::MenuSourceType::MENU_SOURCE_KEYBOARD) &&
- item) {
- views::InkDrop::Get(source)->GetInkDrop()->AnimateToState(
- views::InkDropState::ACTIVATED);
- }
- // Only selected shelf items with context menu opened can be dragged.
- if (context_menu && item && ShelfButtonIsInDrag(item->type, source) &&
- source_type == ui::MenuSourceType::MENU_SOURCE_TOUCH) {
- run_types |= views::MenuRunner::SEND_GESTURE_EVENTS_TO_OWNER;
- }
- shelf_menu_model_adapter_ = std::make_unique<ShelfMenuModelAdapter>(
- item ? item->id.app_id : std::string(), std::move(menu_model), source,
- source_type,
- base::BindOnce(&ShelfView::OnMenuClosed, base::Unretained(this), source),
- IsTabletModeEnabled(),
- /*for_application_menu_items*/ !context_menu);
- shelf_menu_model_adapter_->Run(
- GetMenuAnchorRect(*source, click_point, context_menu),
- shelf_->IsHorizontalAlignment()
- ? views::MenuAnchorPosition::kBubbleTopRight
- : views::MenuAnchorPosition::kBubbleLeft,
- run_types);
- if (!context_menu_shown_callback_.is_null())
- context_menu_shown_callback_.Run();
- }
- void ShelfView::OnMenuClosed(views::View* source) {
- menu_owner_ = nullptr;
- context_menu_id_ = ShelfID();
- closing_event_time_ = shelf_menu_model_adapter_->GetClosingEventTime();
- const ShelfItem* item = ShelfItemForView(source);
- if (item)
- static_cast<ShelfAppButton*>(source)->OnMenuClosed();
- shelf_menu_model_adapter_.reset();
- const bool is_in_drag = item && ShelfButtonIsInDrag(item->type, source);
- // Update the shelf visibility since auto-hide or alignment might have
- // changes, but don't update if shelf item is being dragged. Since shelf
- // should be kept as visible during shelf item drag even menu is closed.
- if (!is_in_drag)
- shelf_->UpdateVisibilityState();
- }
- void ShelfView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
- shelf_->NotifyShelfIconPositionsChanged();
- // Do not call PreferredSizeChanged() so that container does not re-layout
- // during the bounds animation.
- }
- void ShelfView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
- shelf_->set_is_tablet_mode_animation_running(false);
- if (move_animation_tracker_) {
- move_animation_tracker_->Stop();
- move_animation_tracker_.reset();
- }
- 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 ShelfAppButton 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.
- const auto& entries = view_model_->entries();
- const auto iter = std::find_if(
- entries.begin(), entries.end(), [this](const auto& entry) {
- return entry.view == snap_back_from_rip_off_view_;
- });
- if (iter != entries.end())
- snap_back_from_rip_off_view_->ClearState(ShelfAppButton::STATE_HIDDEN);
- snap_back_from_rip_off_view_ = nullptr;
- }
- }
- }
- 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 auto view_index = view_model_->GetIndexOfView(view);
- return (!view_index.has_value()) ? nullptr
- : &(model_->items()[view_index.value()]);
- }
- 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;
- }
- bool ShelfView::ShouldHandleGestures(const ui::GestureEvent& event) const {
- if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN) {
- float x_offset = event.details().scroll_x_hint();
- float y_offset = event.details().scroll_y_hint();
- if (!shelf_->IsHorizontalAlignment())
- std::swap(x_offset, y_offset);
- return std::abs(x_offset) < std::abs(y_offset);
- }
- return true;
- }
- std::u16string ShelfView::GetTitleForChildView(const views::View* view) const {
- const ShelfItem* item = ShelfItemForView(view);
- return item ? item->title : std::u16string();
- }
- void ShelfView::UpdateShelfItemViewsVisibility() {
- visible_views_indices_.clear();
- for (size_t i = 0; i < view_model_->view_size(); ++i) {
- View* view = view_model_->view_at(i);
- // 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().
- const bool has_to_show = dragged_off_shelf_ && view == drag_view();
- const bool is_visible = has_to_show || IsItemVisible(model()->items()[i]);
- view->SetVisible(is_visible);
- if (is_visible)
- visible_views_indices_.push_back(i);
- }
- }
- void ShelfView::DestroyScopedDisplay() {
- scoped_display_for_new_windows_.reset();
- }
- int ShelfView::CalculateAppIconsLayoutOffset() const {
- const ScrollableShelfView* scrollable_shelf_view =
- shelf_->hotseat_widget()->scrollable_shelf_view();
- const gfx::Insets& edge_padding_insets =
- scrollable_shelf_view->edge_padding_insets();
- // Note that `edge_padding_insets` fetched from `scrollable_shelf_view` is
- // mirrored under RTL.
- if (scrollable_shelf_view->ShouldAdaptToRTL())
- return edge_padding_insets.right();
- return shelf_->IsHorizontalAlignment() ? edge_padding_insets.left()
- : edge_padding_insets.top();
- }
- gfx::Rect ShelfView::GetChildViewTargetMirroredBounds(
- const views::View* child) const {
- DCHECK_EQ(this, child->parent());
- return GetMirroredRect(bounds_animator_->GetTargetBounds(child));
- }
- void ShelfView::HandleShelfParty() {
- UpdateShelfItemViewsVisibility();
- PreferredSizeChanged();
- AnimateToIdealBounds();
- }
- void ShelfView::RemoveGhostView() {
- if (current_ghost_view_) {
- current_ghost_view_index_ = absl::nullopt;
- current_ghost_view_->FadeOut();
- current_ghost_view_ = nullptr;
- }
- if (last_ghost_view_) {
- last_ghost_view_->FadeOut();
- last_ghost_view_ = nullptr;
- }
- }
- void ShelfView::ResetActiveMenuModelRequest() {
- context_menu_callback_.Cancel();
- item_awaiting_response_ = ShelfID();
- }
- BEGIN_METADATA(ShelfView, views::AccessiblePaneView)
- END_METADATA
- } // namespace ash
|