// 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.
#ifndef ASH_WM_SESSION_STATE_ANIMATOR_H_
#define ASH_WM_SESSION_STATE_ANIMATOR_H_
#include "ash/ash_export.h"
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/time/time.h"
namespace ash {
// Displays onscreen animations for session state changes (lock/unlock, sign
// out, shut down).
class ASH_EXPORT SessionStateAnimator {
public:
// Animations that can be applied to groups of containers.
enum AnimationType {
ANIMATION_PARTIAL_CLOSE = 0,
ANIMATION_UNDO_PARTIAL_CLOSE,
ANIMATION_FULL_CLOSE,
ANIMATION_FADE_IN,
ANIMATION_FADE_OUT,
ANIMATION_HIDE_IMMEDIATELY,
ANIMATION_RESTORE,
// Animations that raise/lower windows to/from area "in front" of the
// screen.
ANIMATION_LIFT,
ANIMATION_UNDO_LIFT,
ANIMATION_DROP,
// Animations that raise/lower windows from/to area "behind" of the screen.
ANIMATION_RAISE_TO_SCREEN,
ANIMATION_LOWER_BELOW_SCREEN,
ANIMATION_PARTIAL_FADE_IN,
ANIMATION_UNDO_PARTIAL_FADE_IN,
ANIMATION_FULL_FADE_IN,
ANIMATION_GRAYSCALE_BRIGHTNESS,
ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
};
// Constants for determining animation speed.
enum AnimationSpeed {
// Immediately change state.
ANIMATION_SPEED_IMMEDIATE = 0,
// Speed for animations associated with user action that can be undone.
// Used for pre-lock and pre-shutdown animations.
ANIMATION_SPEED_UNDOABLE,
// Speed for animation that reverts undoable action. Used for aborting
// pre-lock and pre-shutdown animations.
ANIMATION_SPEED_REVERT,
// Speed for user action that can not be undone, Used for lock and shutdown
// animations requested via menus/shortcuts and for animating remaining
// parts of partial lock/shutdown animations.
ANIMATION_SPEED_FAST,
// Speed for lock screen appearance in "old" animation set.
ANIMATION_SPEED_SHOW_LOCK_SCREEN,
// Speed for workspace-like animations in "new" animation set.
ANIMATION_SPEED_MOVE_WINDOWS,
// Speed for undoing workspace-like animations in "new" animation set.
ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
// Speed for shutdown in "new" animation set.
ANIMATION_SPEED_SHUTDOWN,
// Speed for reverting shutdown in "new" animation set.
ANIMATION_SPEED_REVERT_SHUTDOWN,
};
// Specific containers or groups of containers that can be animated.
enum Container {
DESKTOP_BACKGROUND = 1 << 0,
LAUNCHER = 1 << 1,
// All user session related containers including system background but
// not including desktop background (wallpaper).
NON_LOCK_SCREEN_CONTAINERS = 1 << 2,
// Desktop wallpaper is moved to this layer when screen is locked.
// This layer is excluded from lock animation so that wallpaper stays as is,
// user session windows are hidden and lock UI is shown on top of it.
// This layer is included in shutdown animation.
LOCK_SCREEN_BACKGROUND = 1 << 3,
// Lock screen and lock screen modal containers.
LOCK_SCREEN_CONTAINERS = 1 << 4,
// Multiple system layers belong here like status, menu, tooltip
// and overlay layers.
LOCK_SCREEN_RELATED_CONTAINERS = 1 << 5,
// The primary root window.
ROOT_CONTAINER = 1 << 6,
};
// A bitfield mask including LOCK_SCREEN_WALLPAPER,
// LOCK_SCREEN_CONTAINERS, and LOCK_SCREEN_RELATED_CONTAINERS.
static const int kAllLockScreenContainersMask;
// A bitfield mask of all containers except the ROOT_CONTAINER.
static const int kAllNonRootContainersMask;
// The AnimationSequence groups together multiple animations and invokes a
// callback once all contained animations are completed successfully.
// Subclasses of AnimationSequence should call one of OnAnimationCompleted or
// OnAnimationAborted once and behaviour is undefined if called multiple
// times.
// AnimationSequences will destroy themselves once EndSquence and one of
// OnAnimationCompleted or OnAnimationAborted has been called.
//
// Typical usage:
// AnimationSequence* animation_sequence =
// session_state_animator->BeginAnimationSequence(some_callback);
// animation_sequence->StartAnimation(
// SessionStateAnimator::LAUNCHER,
// SessionStateAnimator::ANIMATION_FADE_IN,
// SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
// animation_sequence->StartAnimation(
// SessionStateAnimator::LAUNCHER,
// SessionStateAnimator::ANIMATION_FADE_IN,
// SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
// animation_sequence->EndSequence();
// // some_callback won't be called until here even if the animations
// // were completed before the EndSequence call.
//
class ASH_EXPORT AnimationSequence {
public:
virtual ~AnimationSequence();
// Apply animation |type| to all containers included in |container_mask|
// with specified |speed|.
virtual void StartAnimation(int container_mask,
AnimationType type,
AnimationSpeed speed) = 0;
// Ends the animation sequence and enables the callback to be invoked
// when the animation sequence has completed. No more animations should be
// started after EndSequence is called because the AnimationSequenceObserver
// may have destroyed itself.
// NOTE: Clients of AnimationSequence should not access it after EndSequence
// has been called.
virtual void EndSequence();
protected:
// AnimationSequence should not be instantiated directly, only through
// subclasses.
explicit AnimationSequence(base::Closure callback);
// Subclasses should call this when the contained animations completed
// successfully.
// NOTE: This should NOT be accessed after OnAnimationCompleted has been
// called.
virtual void OnAnimationCompleted();
// Subclasses should call this when the contained animations did NOT
// complete successfully.
// NOTE: This should NOT be accessed after OnAnimationAborted has been
// called.
virtual void OnAnimationAborted();
private:
// Destroys this and calls the callback if the contained animations
// completed successfully.
void CleanupIfSequenceCompleted();
// Tracks whether the sequence has ended.
bool sequence_ended_;
// Track whether the contained animations have completed or not, both
// successfully and unsuccessfully.
bool animation_completed_;
// Flag to specify whether the callback should be invoked once the sequence
// has completed.
bool invoke_callback_;
// Callback to be called.
base::Closure callback_;
DISALLOW_COPY_AND_ASSIGN(AnimationSequence);
};
SessionStateAnimator();
virtual ~SessionStateAnimator();
// Reports animation duration for |speed|.
virtual base::TimeDelta GetDuration(AnimationSpeed speed);
// Apply animation |type| to all containers included in |container_mask| with
// specified |speed|.
virtual void StartAnimation(int container_mask,
AnimationType type,
AnimationSpeed speed) = 0;
// Apply animation |type| to all containers included in |container_mask| with
// specified |speed| and call a |callback| at the end of the animation, if it
// is not null.
virtual void StartAnimationWithCallback(
int container_mask,
AnimationType type,
AnimationSpeed speed,
base::Closure callback) = 0;
// Begins an animation sequence. Use this when you need to be notified when
// a group of animations are completed. See AnimationSequence documentation
// for more details.
virtual AnimationSequence* BeginAnimationSequence(
base::Closure callback) = 0;
// Retruns true if the background is hidden.
virtual bool IsBackgroundHidden() const = 0;
// Shows the background immediately.
virtual void ShowBackground() = 0;
// Hides the background immediately.
virtual void HideBackground() = 0;
private:
DISALLOW_COPY_AND_ASSIGN(SessionStateAnimator);
};
} // namespace ash
#endif // ASH_WM_SESSION_STATE_ANIMATOR_H_