ash/wm/session_state_animator.h

   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 "ash/wm/workspace/colored_window_controller.h"
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/timer/timer.h"
  13 #include "ui/aura/window.h"
  14 #include "ui/compositor/layer_animation_observer.h"
  15
  16 namespace gfx {
  17 class Rect;
  18 class Size;
  19 }
  20
  21 namespace ui {
  22 class Layer;
  23 }
  24
  25 namespace ash {
  26 namespace internal {
  27
  28 // Displays onscreen animations for session state changes (lock/unlock, sign
  29 // out, shut down).
  30 class ASH_EXPORT SessionStateAnimator {
  31  public:
  32   // Animations that can be applied to groups of containers.
  33   enum AnimationType {
  34     ANIMATION_PARTIAL_CLOSE = 0,
  35     ANIMATION_UNDO_PARTIAL_CLOSE,
  36     ANIMATION_FULL_CLOSE,
  37     ANIMATION_FADE_IN,
  38     ANIMATION_FADE_OUT,
  39     ANIMATION_HIDE_IMMEDIATELY,
  40     ANIMATION_RESTORE,
  41     // Animations that raise/lower windows to/from area "in front" of the
  42     // screen.
  43     ANIMATION_LIFT,
  44     ANIMATION_UNDO_LIFT,
  45     ANIMATION_DROP,
  46     // Animations that raise/lower windows from/to area "behind" of the screen.
  47     ANIMATION_RAISE_TO_SCREEN,
  48     ANIMATION_LOWER_BELOW_SCREEN,
  49     ANIMATION_PARTIAL_FADE_IN,
  50     ANIMATION_UNDO_PARTIAL_FADE_IN,
  51     ANIMATION_FULL_FADE_IN,
  52     ANIMATION_GRAYSCALE_BRIGHTNESS,
  53     ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
  54   };
  55
  56   // Constants for determining animation speed.
  57   enum AnimationSpeed {
  58     // Immediately change state.
  59     ANIMATION_SPEED_IMMEDIATE = 0,
  60     // Speed for animations associated with user action that can be undone.
  61     // Used for pre-lock and pre-shutdown animations.
  62     ANIMATION_SPEED_UNDOABLE,
  63     // Speed for animation that reverts undoable action. Used for aborting
  64     // pre-lock and pre-shutdown animations.
  65     ANIMATION_SPEED_REVERT,
  66     // Speed for user action that can not be undone, Used for lock and shutdown
  67     // animations requested via menus/shortcuts and for animating remaining
  68     // parts of partial lock/shutdown animations.
  69     ANIMATION_SPEED_FAST,
  70     // Speed for lock screen appearance in "old" animation set.
  71     ANIMATION_SPEED_SHOW_LOCK_SCREEN,
  72     // Speed for workspace-like animations in "new" animation set.
  73     ANIMATION_SPEED_MOVE_WINDOWS,
  74     // Speed for undoing workspace-like animations in "new" animation set.
  75     ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
  76     // Speed for shutdown in "new" animation set.
  77     ANIMATION_SPEED_SHUTDOWN,
  78     // Speed for reverting shutdown in "new" animation set.
  79     ANIMATION_SPEED_REVERT_SHUTDOWN,
  80   };
  81
  82   // Specific containers or groups of containers that can be animated.
  83   enum Container {
  84     DESKTOP_BACKGROUND = 1 << 0,
  85     LAUNCHER = 1 << 1,
  86
  87     // All user session related containers including system background but
  88     // not including desktop background (wallpaper).
  89     NON_LOCK_SCREEN_CONTAINERS = 1 << 2,
  90
  91     // Desktop wallpaper is moved to this layer when screen is locked.
  92     // This layer is excluded from lock animation so that wallpaper stays as is,
  93     // user session windows are hidden and lock UI is shown on top of it.
  94     // This layer is included in shutdown animation.
  95     LOCK_SCREEN_BACKGROUND = 1 << 3,
  96
  97     // Lock screen and lock screen modal containers.
  98     LOCK_SCREEN_CONTAINERS = 1 << 4,
  99
 100     // Multiple system layers belong here like status, menu, tooltip
 101     // and overlay layers.
 102     LOCK_SCREEN_RELATED_CONTAINERS = 1 << 5,
 103   };
 104
 105   // Helper class used by tests to access internal state.
 106   class ASH_EXPORT TestApi {
 107    public:
 108     explicit TestApi(SessionStateAnimator* animator)
 109         : animator_(animator) {}
 110
 111     // Returns true if containers of a given |container_mask|
 112     // were last animated with |type| (probably; the analysis is fairly ad-hoc).
 113     // |container_mask| is a bitfield of a Container.
 114     bool ContainersAreAnimated(int container_mask, AnimationType type) const;
 115
 116     // Returns true if root window was last animated with |type| (probably;
 117     // the analysis is fairly ad-hoc).
 118     bool RootWindowIsAnimated(AnimationType type) const;
 119
 120    private:
 121     SessionStateAnimator* animator_;  // not owned
 122
 123     DISALLOW_COPY_AND_ASSIGN(TestApi);
 124   };
 125
 126   // A bitfield mask including LOCK_SCREEN_WALLPAPER,
 127   // LOCK_SCREEN_CONTAINERS, and LOCK_SCREEN_RELATED_CONTAINERS.
 128   const static int kAllLockScreenContainersMask;
 129
 130   // A bitfield mask of all containers.
 131   const static int kAllContainersMask;
 132
 133   SessionStateAnimator();
 134   virtual ~SessionStateAnimator();
 135
 136   // Reports animation duration for |speed|.
 137   static base::TimeDelta GetDuration(AnimationSpeed speed);
 138
 139   // Fills |containers| with the containers included in |container_mask|.
 140   static void GetContainers(int container_mask,
 141                             aura::Window::Windows* containers);
 142
 143   // Create |foreground_| layer if it doesn't already exist, but makes it
 144   // completely transparent.
 145   void CreateForeground();
 146   // Destroy |foreground_| when it is not needed anymore.
 147   void DropForeground();
 148
 149   // Apply animation |type| to all containers included in |container_mask| with
 150   // specified |speed|.
 151   void StartAnimation(int container_mask,
 152                       AnimationType type,
 153                       AnimationSpeed speed);
 154
 155   // Apply animation |type| to all containers included in |container_mask| with
 156   // specified |speed| and call a |callback| at the end of the animation, if it
 157   // is not null.
 158   void StartAnimationWithCallback(int container_mask,
 159                                   AnimationType type,
 160                                   AnimationSpeed speed,
 161                                   base::Callback<void(void)>& callback);
 162
 163 //  Apply animation |type| to all containers included in |container_mask| with
 164 // specified |speed| and add |observer| to all animations.
 165   void StartAnimationWithObserver(int container_mask,
 166                                   AnimationType type,
 167                                   AnimationSpeed speed,
 168                                   ui::LayerAnimationObserver* observer);
 169
 170   // Applies animation |type| whith specified |speed| to the root container.
 171   void StartGlobalAnimation(AnimationType type,
 172                             AnimationSpeed speed);
 173
 174   // Apply animation |type| to window |window| with |speed| and add |observer|
 175   // if it is not NULL to the last animation sequence.
 176   void RunAnimationForWindow(aura::Window* window,
 177                              AnimationType type,
 178                              AnimationSpeed speed,
 179                              ui::LayerAnimationObserver* observer);
 180
 181   // White foreground that is used during shutdown animation to "fade
 182   // everything into white".
 183   scoped_ptr<ColoredWindowController> foreground_;
 184
 185   DISALLOW_COPY_AND_ASSIGN(SessionStateAnimator);
 186 };
 187
 188 }  // namespace internal
 189 }  // namespace ash
 190
 191 #endif  // ASH_WM_SESSION_STATE_ANIMATOR_H_