// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ASH_SHELF_SHELF_APP_BUTTON_H_
#define ASH_SHELF_SHELF_APP_BUTTON_H_
#include "ash/ash_export.h"
#include "ash/public/cpp/shelf_types.h"
#include "ash/shelf/shelf_button.h"
#include "ash/shelf/shelf_button_delegate.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "ui/base/metadata/metadata_header_macros.h"
#include "ui/base/models/image_model.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/gfx/shadow_value.h"
#include "ui/views/animation/ink_drop_observer.h"
#include "ui/views/animation/ink_drop_state.h"
#include "ui/views/controls/image_view.h"
namespace ash {
struct ShelfItem;
class DotIndicator;
class ProgressIndicator;
class ShelfView;
// Button used for app shortcuts on the shelf.
class ASH_EXPORT ShelfAppButton : public ShelfButton,
public views::InkDropObserver,
public ui::ImplicitAnimationObserver {
METADATA_HEADER(ShelfAppButton, ShelfButton)
public:
// Used to indicate the current state of the button.
enum State {
// Nothing special. Usually represents an app shortcut item with no running
// instance.
STATE_NORMAL = 0,
// Button has mouse hovering on it.
STATE_HOVERED = 1 << 0,
// Underlying ShelfItem has a running instance.
STATE_RUNNING = 1 << 1,
// Underlying ShelfItem needs user's attention.
STATE_ATTENTION = 1 << 2,
// Hide the status (temporarily for some animations).
STATE_HIDDEN = 1 << 3,
// Button is being dragged.
STATE_DRAGGING = 1 << 4,
// App has at least 1 notification.
STATE_NOTIFICATION = 1 << 5,
// Underlying ShelfItem owns the window that is currently active.
STATE_ACTIVE = 1 << 6,
};
// Returns whether |event| should be handled by a ShelfAppButton if a context
// menu for the view is shown. Note that the context menu controller will
// redirect gesture events to the hotseat widget if the context menu was shown
// for a ShelfAppButton). The hotseat widget uses this method to determine
// whether such events can/should be dropped without handling.
static bool ShouldHandleEventFromContextMenu(const ui::GestureEvent* event);
ShelfAppButton(ShelfView* shelf_view,
ShelfButtonDelegate* shelf_button_delegate);
ShelfAppButton(const ShelfAppButton&) = delete;
ShelfAppButton& operator=(const ShelfAppButton&) = delete;
~ShelfAppButton() override;
// Updates the icon image and maybe host badge icon image to display for this
// entry.
void UpdateMainAndMaybeHostBadgeIconImage();
// Retrieve the image to show proxy operations.
gfx::ImageSkia GetImage() const;
// Gets the resized icon image represented by `icon_image_model_` without the
// shadow, assuming the provided `icon_scale`.
gfx::ImageSkia GetIconImage(float icon_scale) const;
const ui::ImageModel& icon_image_model() const { return icon_image_model_; }
views::ImageView* icon_view() { return icon_view_; }
// Returns the badge icon image for the app assuming the provided
// `icon_scale`. Returns an empty image if the app does not have a badge icon.
gfx::ImageSkia GetBadgeIconImage(float icon_scale) const;
// Sets the `icon_image_model_`, and maybe `host_badge_image_` depending on
// `has_host_badge` for this entry. If |is_placeholder_icon| is true, the
// |main_image| will be ignored and this entry will be assigned a placeholder
// vector icon.
void SetMainAndMaybeHostBadgeImage(const gfx::ImageSkia& main_image,
bool is_placeholder_icon,
const gfx::ImageSkia& host_badge_image);
// |state| is or'd into the current state.
void AddState(State state);
void ClearState(State state);
int state() const { return state_; }
// Clears drag drag state that might have been set by gesture handling when a
// gesture ends. No-op if the drag state has already been cleared.
void ClearDragStateOnGestureEnd();
// Returns the bounds of the icon.
gfx::Rect GetIconBounds() const;
// Returns the ideal icon bounds within the button view of the provided size,
// and with the provided icon scale.
gfx::Rect GetIdealIconBounds(const gfx::Size& button_size,
float icon_scale) const;
views::InkDrop* GetInkDropForTesting();
// Called when user started dragging the shelf button.
void OnDragStarted(const ui::LocatedEvent* event);
// Callback used when a menu for this ShelfAppButton is closed.
void OnMenuClosed();
// views::Button overrides:
void ShowContextMenu(const gfx::Point& p,
ui::MenuSourceType source_type) override;
void GetAccessibleNodeData(ui::AXNodeData* node_data) override;
bool ShouldEnterPushedState(const ui::Event& event) override;
// views::View overrides:
bool OnMousePressed(const ui::MouseEvent& event) override;
void OnMouseReleased(const ui::MouseEvent& event) override;
void OnMouseCaptureLost() override;
bool OnMouseDragged(const ui::MouseEvent& event) override;
void Layout(PassKey) override;
void ChildPreferredSizeChanged(views::View* child) override;
void OnThemeChanged() override;
// Update button state from ShelfItem.
void ReflectItemStatus(const ShelfItem& item);
// Returns whether the icon size is up to date.
bool IsIconSizeCurrent();
// Called when the request for the context menu model is canceled.
void OnContextMenuModelRequestCanceled();
bool FireDragTimerForTest();
void FireRippleActivationTimerForTest();
// Return the bounds in the local coordinates enclosing the small ripple area.
gfx::Rect CalculateSmallRippleArea() const;
// Sets up the button to simulate promise app UI (icon scaled down, with
// progress indicator shown), and animates the button into the normal app UI
// (hides the progress indicator, and scales the app icon up).
// Used to animate the button in when it's replacing a promise icon.
// `fallback_icon` - the promise app icon that should be used while the app
// button is animating in. The installed app icon is loaded asynchronously, so
// there is a noticeable delay before the icon becomes available. Using
// fallback icon during animation prevents jankiness in the time period the
// app icon is loading. The jankiness manifests itself as the app icon
// disappearing for a moment after the promise icon is installed.
// `callback` - callback run when the animation completes.
void AnimateInFromPromiseApp(const ui::ImageModel& fallback_icon,
const base::RepeatingClosure& callback);
void SetNotificationBadgeColor(SkColor color);
float progress() { return progress_; }
AppStatus app_status() { return app_status_; }
const std::string& package_id() const { return package_id_; }
bool is_promise_app() const { return is_promise_app_; }
ProgressIndicator* GetProgressIndicatorForTest() const;
protected:
gfx::ImageSkia GetHostBadgeImageForTest() { return host_badge_image_; }
// ui::EventHandler:
void OnGestureEvent(ui::GestureEvent* event) override;
// ui::ImplicitAnimationObserver:
void OnImplicitAnimationsCompleted() override;
// Sets the icon image with a shadow.
void SetShadowedImage(const gfx::ImageSkia& bitmap);
private:
class AppNotificationIndicatorView;
class AppStatusIndicatorView;
friend class ShelfViewWebAppShortcutTest;
// views::View:
bool HandleAccessibleAction(const ui::AXActionData& action_data) override;
// views::InkDropObserver:
void InkDropAnimationStarted() override;
void InkDropRippleAnimationEnded(views::InkDropState state) override;
// Updates the parts of the button to reflect the current |state_| and
// alignment. This may add or remove views, layout and paint.
void UpdateState();
// Invoked when |touch_drag_timer_| fires to show dragging UI.
void OnTouchDragTimer();
// Invoked when |ripple_activation_timer_| fires to activate the ink drop.
void OnRippleTimer();
// Calculates the preferred size of the icon for the provided `icon_scale`.
// This is the actual size of the main app icon that is painted in the grid.
// with the adjusted scale.
gfx::Size GetPreferredIconSize(const ui::ImageModel& image_model,
float icon_scale) const;
// Scales up app icon if |scale_up| is true, otherwise scales it back to
// normal size.
void ScaleAppIcon(bool scale_up);
// Calculates the expected icon bounds for an icon view scaled by
// |icon_scale|.
gfx::Rect GetIconViewBounds(const gfx::Rect& button_bounds,
float icon_scale,
bool ignore_shadow_insets) const;
// Calculates the bounds for either the shortcut icon container or shortcut
// icon scaled by `icon_scale`.
gfx::Rect GetShortcutViewBounds(const gfx::Rect& button_bounds,
float icon_scale,
const float icon_size) const;
// Calculates the notification indicator bounds when scaled by |scale|.
gfx::Rect GetNotificationIndicatorBounds(float scale);
// Calculates the transform between the icon scaled by |icon_scale| and the
// normal size icon.
gfx::Transform GetScaleTransform(float icon_scale);
// Marks whether the ink drop animation has started or not.
void SetInkDropAnimationStarted(bool started);
// Maybe hides the ink drop at the end of gesture handling.
void MaybeHideInkDropWhenGestureEnds();
// Updates the layer bounds for the `progress_indicator_` if any is currently
// active.
void UpdateProgressRingBounds();
// Sets the host badge image to display for this entry
void SetHostBadgeImage(const gfx::ImageSkia& host_badge_image);
// Whether the image view has a placeholder icon in place. The placeholder
// icon is represented as a VectorIcon in the ImageModel. Depending on the
// case, the icon may use the `icon_image_model` or the
// `fallback_icon_image_model` (ie, when an animation in for the promise app
// is happening) for this calceulation.
bool ImageModelHasPlaceholderIcon() const;
// Returns the preferred icon size for promise icons depending on this
// button's `app_state_`. Different from `GetPreferredIconSize()` since
// `GetIconDimensionByAppState()` is used to adjust padding for the promise
// ring.
float GetIconDimensionByAppState() const;
// Called when the app button completes animating in from a promise app state.
void OnAnimatedInFromPromiseApp(base::RepeatingClosure callback);
void UpdateAccessibleDescription();
// The icon part of a button can be animated independently of the rest.
raw_ptr<views::ImageView> icon_view_ = nullptr;
// The ShelfView showing this ShelfAppButton. Owned by RootWindowController.
const raw_ptr<ShelfView> shelf_view_;
// Draws an indicator underneath the image to represent the state of the
// application.
const raw_ptr<AppStatusIndicatorView> indicator_;
// Draws an indicator in the top right corner of the image to represent an
// active notification.
raw_ptr<DotIndicator> notification_indicator_ = nullptr;
// The current application state, a bitfield of State enum values.
int state_ = STATE_NORMAL;
gfx::ShadowValues icon_shadows_;
// The model image for this app button.
ui::ImageModel icon_image_model_;
// The bitmap image for the host badge icon if this is an App Shortcut.
gfx::ImageSkia host_badge_image_;
// The scaling factor for displaying the app icon.
float icon_scale_ = 1.0f;
// App status.
AppStatus app_status_ = AppStatus::kReady;
// Item progress. Only applicable if `is_promise_app_` is true.
float progress_ = -1.0f;
// Indicates whether the ink drop animation starts.
bool ink_drop_animation_started_ = false;
// A timer to defer showing drag UI when the shelf button is pressed.
base::OneShotTimer drag_timer_;
// A timer to activate the ink drop ripple during a long press.
base::OneShotTimer ripple_activation_timer_;
// The target visibility of the shelf app's context menu.
// NOTE: when `context_menu_target_visibility_` is true, the context menu may
// not show yet due to the async request for the menu model.
bool context_menu_target_visibility_ = false;
// An object that draws and updates the progress ring around promise app
// icons.
std::unique_ptr<ProgressIndicator> progress_indicator_;
std::unique_ptr<ShelfButtonDelegate::ScopedActiveInkDropCount>
ink_drop_count_;
// Whether the app is a promise app (i.e. an app with pending or installing
// app status).
bool is_promise_app_ = false;
// The package id that is associated with this shelf app.
std::string package_id_;
// Whether the app has a host badge (i.e. an App Shortcut).
bool has_host_badge_ = false;
// The fallback icon used as the app button image when the app is animated in
// from a promise icon. The fallback icon will be used at least until the
// actual app icon has been loaded. This prevents a flash of an empty icon
// when the app icon replaces a promise icon.
ui::ImageModel fallback_icon_image_model_;
// Whether the fallback icon should be used even if the actual app icon is
// available. This will be set animating the app button in from promise app
// state to prevent app icon changes mid animation.
bool force_fallback_icon_ = false;
std::optional<float> forced_progress_indicator_value_;
// Whether the non-placeholder app icon has been loaded for the app.
bool has_icon_image_ = false;
// Used to track whether the menu was deleted while running. Must be last.
base::WeakPtrFactory<ShelfAppButton> weak_factory_{this};
};
} // namespace ash
#endif // ASH_SHELF_SHELF_APP_BUTTON_H_
Codebase Browser
chromium