ui/base/cocoa/constrained_window/constrained_window_animation.mm

   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 #import "ui/base/cocoa/constrained_window/constrained_window_animation.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/location.h"
   9 #import "base/mac/foundation_util.h"
  10 #include "base/native_library.h"
  11 #include "ui/gfx/animation/tween.h"
  12
  13 // The window animations in this file use private APIs as described here:
  14 // http://code.google.com/p/undocumented-goodness/source/browse/trunk/CoreGraphics/CGSPrivate.h
  15 // There are two important things to keep in mind when modifying this file:
  16 // - For most operations the origin of the coordinate system is top left.
  17 // - Perspective and shear transformations get clipped if they are bigger
  18 //   than the window size. This does not seem to apply to scale transformations.
  19
  20 // Length of the animation in seconds.
  21 const NSTimeInterval kAnimationDuration = 0.18;
  22
  23 // The number of pixels above the final destination to animate from.
  24 const CGFloat kShowHideVerticalOffset = 20;
  25
  26 // Scale the window by this factor when animating.
  27 const CGFloat kShowHideScaleFactor = 0.99;
  28
  29 // Size of the perspective effect as a factor of the window width.
  30 const CGFloat kShowHidePerspectiveFactor = 0.04;
  31
  32 // Forward declare private CoreGraphics APIs used to transform windows.
  33 extern "C" {
  34
  35 typedef float float32;
  36
  37 typedef int32 CGSWindow;
  38 typedef int32 CGSConnection;
  39
  40 typedef struct {
  41   float32 x;
  42   float32 y;
  43 } MeshPoint;
  44
  45 typedef struct {
  46   MeshPoint local;
  47   MeshPoint global;
  48 } CGPointWarp;
  49
  50 CGSConnection _CGSDefaultConnection();
  51 CGError CGSSetWindowTransform(const CGSConnection cid,
  52                               const CGSWindow wid,
  53                               CGAffineTransform transform);
  54 CGError CGSSetWindowWarp(const CGSConnection cid,
  55                          const CGSWindow wid,
  56                          int32 w,
  57                          int32 h,
  58                          CGPointWarp* mesh);
  59 CGError CGSSetWindowAlpha(const CGSConnection cid,
  60                           const CGSWindow wid,
  61                           float32 alpha);
  62
  63 }  // extern "C"
  64
  65 namespace {
  66
  67 struct KeyFrame {
  68   float value;
  69   float scale;
  70 };
  71
  72 // Get the window location relative to the top left of the main screen.
  73 // Most Cocoa APIs use a coordinate system where the screen origin is the
  74 // bottom left. The various CGSSetWindow* APIs use a coordinate system where
  75 // the screen origin is the top left.
  76 NSPoint GetCGSWindowScreenOrigin(NSWindow* window) {
  77   NSArray* screens = [NSScreen screens];
  78   if ([screens count] == 0)
  79     return NSZeroPoint;
  80   // Origin is relative to the screen with the menu bar (the screen at index 0).
  81   // Note, this is not the same as mainScreen which is the screen with the key
  82   // window.
  83   NSScreen* main_screen = [screens objectAtIndex:0];
  84
  85   NSRect window_frame = [window frame];
  86   NSRect screen_frame = [main_screen frame];
  87   return NSMakePoint(NSMinX(window_frame),
  88                      NSHeight(screen_frame) - NSMaxY(window_frame));
  89 }
  90
  91 // Set the transparency of the window.
  92 void SetWindowAlpha(NSWindow* window, float alpha) {
  93   CGSConnection cid = _CGSDefaultConnection();
  94   CGSSetWindowAlpha(cid, [window windowNumber], alpha);
  95 }
  96
  97 // Scales the window and translates it so that it stays centered relative
  98 // to its original position.
  99 void SetWindowScale(NSWindow* window, float scale) {
 100   CGFloat scale_delta = 1.0 - scale;
 101   CGFloat cur_scale = 1.0 + scale_delta;
 102   CGAffineTransform transform =
 103       CGAffineTransformMakeScale(cur_scale, cur_scale);
 104
 105   // Translate the window to keep it centered at the original location.
 106   NSSize window_size = [window frame].size;
 107   CGFloat scale_offset_x = window_size.width * (1 - cur_scale) / 2.0;
 108   CGFloat scale_offset_y = window_size.height * (1 - cur_scale) / 2.0;
 109
 110   NSPoint origin = GetCGSWindowScreenOrigin(window);
 111   CGFloat new_x = -origin.x + scale_offset_x;
 112   CGFloat new_y = -origin.y + scale_offset_y;
 113   transform = CGAffineTransformTranslate(transform, new_x, new_y);
 114
 115   CGSConnection cid = _CGSDefaultConnection();
 116   CGSSetWindowTransform(cid, [window windowNumber], transform);
 117 }
 118
 119 // Unsets any window warp that may have been previously applied.
 120 // Window warp prevents other effects such as CGSSetWindowTransform from
 121 // being applied.
 122 void ClearWindowWarp(NSWindow* window) {
 123   CGSConnection cid = _CGSDefaultConnection();
 124   CGSSetWindowWarp(cid, [window windowNumber], 0, 0, NULL);
 125 }
 126
 127 // Applies various transformations using a warp effect. The window is
 128 // translated vertically by |y_offset|. The window is scaled by |scale| and
 129 // translated so that the it remains centered relative to its original position.
 130 // Finally, perspective is effect is applied by shrinking the top of the window.
 131 void SetWindowWarp(NSWindow* window,
 132                    float y_offset,
 133                    float scale,
 134                    float perspective_offset) {
 135   NSRect win_rect = [window frame];
 136   win_rect.origin = NSZeroPoint;
 137   NSRect screen_rect = win_rect;
 138   screen_rect.origin = GetCGSWindowScreenOrigin(window);
 139
 140   // Apply a vertical translate.
 141   screen_rect.origin.y -= y_offset;
 142
 143   // Apply a scale and translate to keep the window centered.
 144   screen_rect.origin.x += (NSWidth(win_rect) - NSWidth(screen_rect)) / 2.0;
 145   screen_rect.origin.y += (NSHeight(win_rect) - NSHeight(screen_rect)) / 2.0;
 146
 147   // A 2 x 2 mesh that maps each corner of the window to a location in screen
 148   // coordinates. Note that the origin of the coordinate system is top, left.
 149   CGPointWarp mesh[2][2] = {
 150       {{
 151         // Top left.
 152         {NSMinX(win_rect), NSMinY(win_rect)},
 153         {NSMinX(screen_rect) + perspective_offset, NSMinY(screen_rect)},
 154        },
 155        {
 156         // Top right.
 157         {NSMaxX(win_rect), NSMinY(win_rect)},
 158         {NSMaxX(screen_rect) - perspective_offset, NSMinY(screen_rect)}, }},
 159       {{
 160         // Bottom left.
 161         {NSMinX(win_rect), NSMaxY(win_rect)},
 162         {NSMinX(screen_rect), NSMaxY(screen_rect)},
 163        },
 164        {
 165         // Bottom right.
 166         {NSMaxX(win_rect), NSMaxY(win_rect)},
 167         {NSMaxX(screen_rect), NSMaxY(screen_rect)}, }},
 168   };
 169
 170   CGSConnection cid = _CGSDefaultConnection();
 171   CGSSetWindowWarp(cid, [window windowNumber], 2, 2, &(mesh[0][0]));
 172 }
 173
 174 // Sets the various effects that are a part of the Show/Hide animation.
 175 // Value is a number between 0 and 1 where 0 means the window is completely
 176 // hidden and 1 means the window is fully visible.
 177 void UpdateWindowShowHideAnimationState(NSWindow* window, CGFloat value) {
 178   CGFloat inverse_value = 1.0 - value;
 179
 180   SetWindowAlpha(window, value);
 181   CGFloat y_offset = kShowHideVerticalOffset * inverse_value;
 182   CGFloat scale = 1.0 - (1.0 - kShowHideScaleFactor) * inverse_value;
 183   CGFloat perspective_offset =
 184       ([window frame].size.width * kShowHidePerspectiveFactor) * inverse_value;
 185
 186   SetWindowWarp(window, y_offset, scale, perspective_offset);
 187 }
 188
 189 }  // namespace
 190
 191 @interface ConstrainedWindowAnimationBase ()
 192 // Subclasses should override these to update the window state for the current
 193 // animation value.
 194 - (void)setWindowStateForStart;
 195 - (void)setWindowStateForValue:(float)value;
 196 - (void)setWindowStateForEnd;
 197 @end
 198
 199 @implementation ConstrainedWindowAnimationBase
 200
 201 - (id)initWithWindow:(NSWindow*)window {
 202   if ((self = [self initWithDuration:kAnimationDuration
 203                       animationCurve:NSAnimationEaseInOut])) {
 204     window_.reset([window retain]);
 205     [self setAnimationBlockingMode:NSAnimationBlocking];
 206     [self setWindowStateForStart];
 207   }
 208   return self;
 209 }
 210
 211 - (void)stopAnimation {
 212   [super stopAnimation];
 213   [self setWindowStateForEnd];
 214   if ([[self delegate] respondsToSelector:@selector(animationDidEnd:)])
 215     [[self delegate] animationDidEnd:self];
 216 }
 217
 218 - (void)setCurrentProgress:(NSAnimationProgress)progress {
 219   [super setCurrentProgress:progress];
 220
 221   if (progress >= 1.0) {
 222     [self setWindowStateForEnd];
 223     return;
 224   }
 225   [self setWindowStateForValue:[self currentValue]];
 226 }
 227
 228 - (void)setWindowStateForStart {
 229   // Subclasses can optionally override this method.
 230 }
 231
 232 - (void)setWindowStateForValue:(float)value {
 233   // Subclasses must override this method.
 234   NOTREACHED();
 235 }
 236
 237 - (void)setWindowStateForEnd {
 238   // Subclasses can optionally override this method.
 239 }
 240
 241 @end
 242
 243 @implementation ConstrainedWindowAnimationShow
 244
 245 - (void)setWindowStateForStart {
 246   SetWindowAlpha(window_, 0.0);
 247 }
 248
 249 - (void)setWindowStateForValue:(float)value {
 250   UpdateWindowShowHideAnimationState(window_, value);
 251 }
 252
 253 - (void)setWindowStateForEnd {
 254   SetWindowAlpha(window_, 1.0);
 255   ClearWindowWarp(window_);
 256 }
 257
 258 @end
 259
 260 @implementation ConstrainedWindowAnimationHide
 261
 262 - (void)setWindowStateForValue:(float)value {
 263   UpdateWindowShowHideAnimationState(window_, 1.0 - value);
 264 }
 265
 266 - (void)setWindowStateForEnd {
 267   SetWindowAlpha(window_, 0.0);
 268   ClearWindowWarp(window_);
 269 }
 270
 271 @end
 272
 273 @implementation ConstrainedWindowAnimationPulse
 274
 275 // Sets the window scale based on the animation progress.
 276 - (void)setWindowStateForValue:(float)value {
 277   KeyFrame frames[] = {
 278       {0.00, 1.0}, {0.40, 1.02}, {0.60, 1.02}, {1.00, 1.0},
 279   };
 280
 281   CGFloat scale = 1;
 282   for (int i = arraysize(frames) - 1; i >= 0; --i) {
 283     if (value >= frames[i].value) {
 284       CGFloat delta = frames[i + 1].value - frames[i].value;
 285       CGFloat frame_progress = (value - frames[i].value) / delta;
 286       scale = gfx::Tween::FloatValueBetween(frame_progress, frames[i].scale,
 287                                             frames[i + 1].scale);
 288       break;
 289     }
 290   }
 291
 292   SetWindowScale(window_, scale);
 293 }
 294
 295 - (void)setWindowStateForEnd {
 296   SetWindowScale(window_, 1.0);
 297 }
 298
 299 @end