Home | History | Annotate | Download | only in wm 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef ASH_WM_SESSION_STATE_ANIMATOR_H_
      6 #define ASH_WM_SESSION_STATE_ANIMATOR_H_
      7 
      8 #include "ash/ash_export.h"
      9 #include "base/basictypes.h"
     10 #include "base/callback.h"
     11 #include "base/time/time.h"
     12 
     13 namespace ash {
     14 
     15 // Displays onscreen animations for session state changes (lock/unlock, sign
     16 // out, shut down).
     17 class ASH_EXPORT SessionStateAnimator {
     18  public:
     19   // Animations that can be applied to groups of containers.
     20   enum AnimationType {
     21     ANIMATION_PARTIAL_CLOSE = 0,
     22     ANIMATION_UNDO_PARTIAL_CLOSE,
     23     ANIMATION_FULL_CLOSE,
     24     ANIMATION_FADE_IN,
     25     ANIMATION_FADE_OUT,
     26     ANIMATION_HIDE_IMMEDIATELY,
     27     ANIMATION_RESTORE,
     28     // Animations that raise/lower windows to/from area "in front" of the
     29     // screen.
     30     ANIMATION_LIFT,
     31     ANIMATION_UNDO_LIFT,
     32     ANIMATION_DROP,
     33     // Animations that raise/lower windows from/to area "behind" of the screen.
     34     ANIMATION_RAISE_TO_SCREEN,
     35     ANIMATION_LOWER_BELOW_SCREEN,
     36     ANIMATION_PARTIAL_FADE_IN,
     37     ANIMATION_UNDO_PARTIAL_FADE_IN,
     38     ANIMATION_FULL_FADE_IN,
     39     ANIMATION_GRAYSCALE_BRIGHTNESS,
     40     ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
     41   };
     42 
     43   // Constants for determining animation speed.
     44   enum AnimationSpeed {
     45     // Immediately change state.
     46     ANIMATION_SPEED_IMMEDIATE = 0,
     47     // Speed for animations associated with user action that can be undone.
     48     // Used for pre-lock and pre-shutdown animations.
     49     ANIMATION_SPEED_UNDOABLE,
     50     // Speed for animation that reverts undoable action. Used for aborting
     51     // pre-lock and pre-shutdown animations.
     52     ANIMATION_SPEED_REVERT,
     53     // Speed for user action that can not be undone, Used for lock and shutdown
     54     // animations requested via menus/shortcuts and for animating remaining
     55     // parts of partial lock/shutdown animations.
     56     ANIMATION_SPEED_FAST,
     57     // Speed for lock screen appearance in "old" animation set.
     58     ANIMATION_SPEED_SHOW_LOCK_SCREEN,
     59     // Speed for workspace-like animations in "new" animation set.
     60     ANIMATION_SPEED_MOVE_WINDOWS,
     61     // Speed for undoing workspace-like animations in "new" animation set.
     62     ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
     63     // Speed for shutdown in "new" animation set.
     64     ANIMATION_SPEED_SHUTDOWN,
     65     // Speed for reverting shutdown in "new" animation set.
     66     ANIMATION_SPEED_REVERT_SHUTDOWN,
     67   };
     68 
     69   // Specific containers or groups of containers that can be animated.
     70   enum Container {
     71     DESKTOP_BACKGROUND = 1 << 0,
     72     LAUNCHER = 1 << 1,
     73 
     74     // All user session related containers including system background but
     75     // not including desktop background (wallpaper).
     76     NON_LOCK_SCREEN_CONTAINERS = 1 << 2,
     77 
     78     // Desktop wallpaper is moved to this layer when screen is locked.
     79     // This layer is excluded from lock animation so that wallpaper stays as is,
     80     // user session windows are hidden and lock UI is shown on top of it.
     81     // This layer is included in shutdown animation.
     82     LOCK_SCREEN_BACKGROUND = 1 << 3,
     83 
     84     // Lock screen and lock screen modal containers.
     85     LOCK_SCREEN_CONTAINERS = 1 << 4,
     86 
     87     // Multiple system layers belong here like status, menu, tooltip
     88     // and overlay layers.
     89     LOCK_SCREEN_RELATED_CONTAINERS = 1 << 5,
     90 
     91     // The primary root window.
     92     ROOT_CONTAINER = 1 << 6,
     93   };
     94 
     95   // A bitfield mask including LOCK_SCREEN_WALLPAPER,
     96   // LOCK_SCREEN_CONTAINERS, and LOCK_SCREEN_RELATED_CONTAINERS.
     97   static const int kAllLockScreenContainersMask;
     98 
     99   // A bitfield mask of all containers except the ROOT_CONTAINER.
    100   static const int kAllNonRootContainersMask;
    101 
    102   // The AnimationSequence groups together multiple animations and invokes a
    103   // callback once all contained animations are completed successfully.
    104   // Subclasses of AnimationSequence should call one of OnAnimationCompleted or
    105   // OnAnimationAborted once and behaviour is undefined if called multiple
    106   // times.
    107   // AnimationSequences will destroy themselves once EndSquence and one of
    108   // OnAnimationCompleted or OnAnimationAborted has been called.
    109   //
    110   // Typical usage:
    111   //  AnimationSequence* animation_sequence =
    112   //      session_state_animator->BeginAnimationSequence(some_callback);
    113   //  animation_sequence->StartAnimation(
    114   //      SessionStateAnimator::LAUNCHER,
    115   //      SessionStateAnimator::ANIMATION_FADE_IN,
    116   //      SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
    117   //  animation_sequence->StartAnimation(
    118   //      SessionStateAnimator::LAUNCHER,
    119   //      SessionStateAnimator::ANIMATION_FADE_IN,
    120   //      SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
    121   //  animation_sequence->EndSequence();
    122   //  // some_callback won't be called until here even if the animations
    123   //  // were completed before the EndSequence call.
    124   //
    125   class ASH_EXPORT AnimationSequence {
    126    public:
    127     virtual ~AnimationSequence();
    128 
    129     // Apply animation |type| to all containers included in |container_mask|
    130     // with specified |speed|.
    131     virtual void StartAnimation(int container_mask,
    132                                 AnimationType type,
    133                                 AnimationSpeed speed) = 0;
    134 
    135     // Ends the animation sequence and enables the callback to be invoked
    136     // when the animation sequence has completed.  No more animations should be
    137     // started after EndSequence is called because the AnimationSequenceObserver
    138     // may have destroyed itself.
    139     // NOTE: Clients of AnimationSequence should not access it after EndSequence
    140     // has been called.
    141     virtual void EndSequence();
    142 
    143    protected:
    144     // AnimationSequence should not be instantiated directly, only through
    145     // subclasses.
    146     explicit AnimationSequence(base::Closure callback);
    147 
    148     // Subclasses should call this when the contained animations completed
    149     // successfully.
    150     // NOTE: This should NOT be accessed after OnAnimationCompleted has been
    151     // called.
    152     virtual void OnAnimationCompleted();
    153 
    154     // Subclasses should call this when the contained animations did NOT
    155     // complete successfully.
    156     // NOTE: This should NOT be accessed after OnAnimationAborted has been
    157     // called.
    158     virtual void OnAnimationAborted();
    159 
    160    private:
    161     // Destroys this and calls the callback if the contained animations
    162     // completed successfully.
    163     void CleanupIfSequenceCompleted();
    164 
    165     // Tracks whether the sequence has ended.
    166     bool sequence_ended_;
    167 
    168     // Track whether the contained animations have completed or not, both
    169     // successfully and unsuccessfully.
    170     bool animation_completed_;
    171 
    172     // Flag to specify whether the callback should be invoked once the sequence
    173     // has completed.
    174     bool invoke_callback_;
    175 
    176     // Callback to be called.
    177     base::Closure callback_;
    178 
    179     DISALLOW_COPY_AND_ASSIGN(AnimationSequence);
    180   };
    181 
    182   SessionStateAnimator();
    183   virtual ~SessionStateAnimator();
    184 
    185   // Reports animation duration for |speed|.
    186   virtual base::TimeDelta GetDuration(AnimationSpeed speed);
    187 
    188   // Apply animation |type| to all containers included in |container_mask| with
    189   // specified |speed|.
    190   virtual void StartAnimation(int container_mask,
    191                               AnimationType type,
    192                               AnimationSpeed speed) = 0;
    193 
    194   // Apply animation |type| to all containers included in |container_mask| with
    195   // specified |speed| and call a |callback| at the end of the animation, if it
    196   // is not null.
    197   virtual void StartAnimationWithCallback(
    198       int container_mask,
    199       AnimationType type,
    200       AnimationSpeed speed,
    201       base::Closure callback) = 0;
    202 
    203   // Begins an animation sequence.  Use this when you need to be notified when
    204   // a group of animations are completed.  See AnimationSequence documentation
    205   // for more details.
    206   virtual AnimationSequence* BeginAnimationSequence(
    207       base::Closure callback) = 0;
    208 
    209   // Retruns true if the background is hidden.
    210   virtual bool IsBackgroundHidden() const = 0;
    211 
    212   // Shows the background immediately.
    213   virtual void ShowBackground() = 0;
    214 
    215   // Hides the background immediately.
    216   virtual void HideBackground() = 0;
    217 
    218  private:
    219   DISALLOW_COPY_AND_ASSIGN(SessionStateAnimator);
    220 };
    221 
    222 }  // namespace ash
    223 
    224 #endif  // ASH_WM_SESSION_STATE_ANIMATOR_H_
    225