// Copyright 2023 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_WM_SCOPED_WINDOW_TUCKER_H_
#define ASH_WM_SCOPED_WINDOW_TUCKER_H_
#include <memory>
#include "ash/wm/mru_window_tracker.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/overview/overview_observer.h"
#include "ash/wm/window_state.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "ui/aura/scoped_window_event_targeting_blocker.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/widget/unique_widget_ptr.h"
#include "ui/wm/public/activation_change_observer.h"
namespace ash {
constexpr char kTuckUserAction[] = "FloatWindowTucked";
constexpr char kUntuckUserAction[] = "FloatWindowUntucked";
// Scoped class which makes modifications while a window is tucked. It owns a
// tuck handle widget that will bring the hidden window back onscreen. Users of
// the class need to ensure that window outlives instance of this class.
class ScopedWindowTucker : public wm::ActivationChangeObserver,
public OverviewObserver,
public aura::WindowObserver {
public:
static constexpr int kTuckHandleWidth = 20;
static constexpr int kTuckHandleHeight = 92;
class Delegate {
public:
Delegate();
virtual ~Delegate();
// Paint the tuck handle.
virtual void PaintTuckHandle(gfx::Canvas* canvas, int width, bool left) = 0;
// Returns `kContainerIdsToMove` for the parent of the handle widget.
virtual int ParentContainerId() const = 0;
// Updates the position of the window.
virtual void UpdateWindowPosition(aura::Window* window, bool left) = 0;
// Destroys `this_`, which will untuck `window_` and set the window bounds
// back onscreen.
virtual void UntuckWindow(aura::Window* window) = 0;
// Hides the window after the tuck animation is finished. This is so it will
// behave similarly to a minimized window in overview.
virtual void OnAnimateTuckEnded(aura::Window* window) = 0;
// Returns proper bounds for tuck handle.
virtual gfx::Rect GetTuckHandleBounds(
bool left,
const gfx::Rect& window_bounds) const = 0;
base::WeakPtr<Delegate> GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
private:
base::WeakPtrFactory<Delegate> weak_ptr_factory_{this};
};
// Represents a tuck handle that untucks floated / PiP windows from offscreen.
class TuckHandleView : public views::Button,
public views::ViewTargeterDelegate {
public:
TuckHandleView(base::WeakPtr<Delegate> delegate,
base::RepeatingClosure callback,
bool left);
TuckHandleView(const TuckHandleView&) = delete;
TuckHandleView& operator=(const TuckHandleView&) = delete;
~TuckHandleView() override;
// views::Button:
void OnThemeChanged() override;
void PaintButtonContents(gfx::Canvas* canvas) override;
void OnGestureEvent(ui::GestureEvent* event) override;
// views::ViewTargeterDelegate:
bool DoesIntersectRect(const views::View* target,
const gfx::Rect& rect) const override;
private:
// The delegate held by `ScopedWindowTucker`.
base::WeakPtr<Delegate> scoped_window_tucker_delegate_;
// Whether the tuck handle is on the left or right edge of the screen. A
// left tuck handle will have the chevron arrow pointing right and vice
// versa.
const bool left_;
};
// Creates an instance for `window` where `left` is the side of the screen
// that the tuck handle is on.
explicit ScopedWindowTucker(std::unique_ptr<Delegate> delegate,
aura::Window* window,
bool left);
ScopedWindowTucker(const ScopedWindowTucker&) = delete;
ScopedWindowTucker& operator=(const ScopedWindowTucker&) = delete;
~ScopedWindowTucker() override;
// Returns the target window the resizer was created for.
aura::Window* window() { return window_; }
// Returns the tuck handle widget that this tucker manages.
views::Widget* tuck_handle_widget() { return tuck_handle_widget_.get(); }
// Returns true if the window is tucked to the left of the screen edge.
bool left() const { return left_; }
// Starts the tucking animation.
void AnimateTuck();
// Starts the untucking animation. Runs `callback` when the animation
// is completed.
void AnimateUntuck(base::OnceClosure callback);
// Runs `delegate`'s `UntuckWindow()`.
void UntuckWindow();
// Runs `delegate`'s `OnAnimateTuckEnded()`.
void OnAnimateTuckEnded();
// wm::ActivationChangeObserver:
void OnWindowActivated(ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) override;
// OverviewObserver:
void OnOverviewModeStarting() override;
void OnOverviewModeEndingAnimationComplete(bool canceled) override;
// aura::WindowObserver:
void OnWindowBoundsChanged(aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds,
ui::PropertyChangeReason reason) override;
private:
// Initializes the tuck handle widget.
void InitializeTuckHandleWidget();
// Slides the tuck handle offscreen and onscreen when entering and exiting
// overview mode respectively.
void OnOverviewModeChanged(bool in_overview);
std::unique_ptr<Delegate> delegate_;
// The window that is being tucked. Will be tucked and untucked by the tuck
// handle.
raw_ptr<aura::Window> window_;
// True if the window is tucked to the left screen edge, false otherwise.
bool left_ = false;
// Blocks events from hitting the window while `this` is alive.
aura::ScopedWindowEventTargetingBlocker event_blocker_;
views::UniqueWidgetPtr tuck_handle_widget_ =
std::make_unique<views::Widget>();
base::ScopedObservation<OverviewController, OverviewObserver>
overview_observer_{this};
base::ScopedObservation<aura::Window, aura::WindowObserver>
window_observation_{this};
base::WeakPtrFactory<ScopedWindowTucker> weak_factory_{this};
};
} // namespace ash
#endif // ASH_WM_SCOPED_WINDOW_TUCKER_H_
Codebase Browser
chromium