mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 04:57:03 +00:00
515 lines
13 KiB
Plaintext
515 lines
13 KiB
Plaintext
/*
|
|
* CPAnimation.j
|
|
* AppKit
|
|
*
|
|
* Created by Francisco Tolmasky.
|
|
* Copyright 2008, 280 North, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
@import <Foundation/CPObject.j>
|
|
@import <Foundation/CPTimer.j>
|
|
|
|
@import "CAMediaTimingFunction.j"
|
|
|
|
|
|
@protocol CPAnimationDelegate <CPObject>
|
|
|
|
@optional
|
|
- (BOOL)animationShouldStart:(CPAnimation)animation;
|
|
- (float)animation:(CPAnimation)animation valueForProgress:(float)progress;
|
|
- (void)animationDidEnd:(CPAnimation)animation;
|
|
- (void)animationDidStop:(CPAnimation)animation;
|
|
|
|
@end
|
|
|
|
|
|
var CPAnimationDelegate_animationShouldStart_ = 1 << 1,
|
|
CPAnimationDelegate_animation_valueForProgress_ = 1 << 2,
|
|
CPAnimationDelegate_animationDidEnd_ = 1 << 3,
|
|
CPAnimationDelegate_animationDidStop_ = 1 << 4;
|
|
|
|
@typedef CPAnimationCurve
|
|
CPAnimationEaseInOut = 0;
|
|
CPAnimationEaseIn = 1;
|
|
CPAnimationEaseOut = 2;
|
|
CPAnimationLinear = 3;
|
|
|
|
ACTUAL_FRAME_RATE = 0;
|
|
|
|
/*!
|
|
@ingroup appkit
|
|
@class CPAnimation
|
|
|
|
Manages an animation. Contains timing and progress information.
|
|
|
|
@par Delegate Methods
|
|
|
|
@delegate -(BOOL)animationShouldStart:(CPAnimation)animation;
|
|
Called at the beginning of \c -startAnimation.
|
|
@param animation the animation that will start
|
|
@return \c YES allows the animation to start.
|
|
\c NO stops the animation.
|
|
|
|
@delegate -(void)animationDidEnd:(CPAnimation)animation;
|
|
Called when an animation has completed.
|
|
@param animation the animation that completed
|
|
|
|
@delegate -(void)animationDidStop:(CPAnimation)animation;
|
|
Called when the animation was stopped (before completing).
|
|
@param animation the animation that was stopped
|
|
|
|
@delegate - (float)animation:(CPAnimation)animation valueForProgress:(float)progress;
|
|
The value from this method will be returned when CPAnimation's
|
|
\c currentValue method is called.
|
|
@param animation the animation to obtain the curve value for
|
|
@param progress the current animation progress
|
|
@return the curve value
|
|
*/
|
|
@implementation CPAnimation : CPObject
|
|
{
|
|
CPTimeInterval _lastTime;
|
|
CPTimeInterval _duration;
|
|
|
|
CPAnimationCurve _animationCurve;
|
|
CAMediaTimingFunction _timingFunction;
|
|
|
|
float _frameRate;
|
|
float _progress;
|
|
|
|
id <CPAnimationDelegate> _delegate;
|
|
CPTimer _timer;
|
|
unsigned _implementedDelegateMethods;
|
|
}
|
|
|
|
/*!
|
|
Initializes the animation with a duration and animation curve.
|
|
@param aDuration the length of the animation
|
|
@param anAnimationCurve defines the animation's pace
|
|
@throws CPInvalidArgumentException if an invalid animation curve is specified
|
|
*/
|
|
- (id)initWithDuration:(float)aDuration animationCurve:(CPAnimationCurve)anAnimationCurve
|
|
{
|
|
self = [super init];
|
|
|
|
if (self)
|
|
{
|
|
_progress = 0.0;
|
|
_duration = MAX(0.0, aDuration);
|
|
_frameRate = 60.0;
|
|
|
|
[self setAnimationCurve:anAnimationCurve];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
/*!
|
|
Sets the animation's pace.
|
|
@param anAnimationCurve the animation's pace
|
|
@throws CPInvalidArgumentException if an invalid animation curve is specified
|
|
*/
|
|
- (void)setAnimationCurve:(CPAnimationCurve)anAnimationCurve
|
|
{
|
|
var timingFunctionName;
|
|
|
|
switch (anAnimationCurve)
|
|
{
|
|
case CPAnimationEaseInOut:
|
|
timingFunctionName = kCAMediaTimingFunctionEaseInEaseOut;
|
|
break;
|
|
|
|
case CPAnimationEaseIn:
|
|
timingFunctionName = kCAMediaTimingFunctionEaseIn;
|
|
break;
|
|
|
|
case CPAnimationEaseOut:
|
|
timingFunctionName = kCAMediaTimingFunctionEaseOut;
|
|
break;
|
|
|
|
case CPAnimationLinear:
|
|
timingFunctionName = kCAMediaTimingFunctionLinear;
|
|
break;
|
|
|
|
default:
|
|
[CPException raise:CPInvalidArgumentException
|
|
reason:@"Invalid value provided for animation curve"];
|
|
break;
|
|
}
|
|
|
|
_animationCurve = anAnimationCurve;
|
|
_timingFunction = [CAMediaTimingFunction functionWithName:timingFunctionName];
|
|
}
|
|
|
|
/*!
|
|
Returns the animation's pace
|
|
*/
|
|
- (CPAnimationCurve)animationCurve
|
|
{
|
|
return _animationCurve;
|
|
}
|
|
|
|
/*!
|
|
Sets the animation's length.
|
|
@param aDuration the new animation length
|
|
@throws CPInvalidArgumentException if \c aDuration is negative
|
|
*/
|
|
- (void)setDuration:(CPTimeInterval)aDuration
|
|
{
|
|
if (aDuration < 0)
|
|
[CPException raise:CPInvalidArgumentException reason:"aDuration can't be negative"];
|
|
|
|
_duration = aDuration;
|
|
}
|
|
|
|
/*!
|
|
Returns the length of the animation.
|
|
*/
|
|
- (CPTimeInterval)duration
|
|
{
|
|
return _duration;
|
|
}
|
|
|
|
/*!
|
|
Sets the animation frame rate. This is not a guaranteed frame rate. 0 means to go as fast as possible.
|
|
@param frameRate the new desired frame rate
|
|
@throws CPInvalidArgumentException if \c frameRate is negative
|
|
*/
|
|
- (void)setFrameRate:(float)frameRate
|
|
{
|
|
if (frameRate < 0)
|
|
[CPException raise:CPInvalidArgumentException reason:"frameRate can't be negative"];
|
|
|
|
_frameRate = frameRate;
|
|
}
|
|
|
|
/*!
|
|
Returns the desired frame rate.
|
|
*/
|
|
- (float)frameRate
|
|
{
|
|
return _frameRate;
|
|
}
|
|
|
|
/*!
|
|
Returns the animation's delegate
|
|
*/
|
|
- (id)delegate
|
|
{
|
|
return _delegate;
|
|
}
|
|
|
|
/*!
|
|
Sets the animation's delegate.
|
|
@param aDelegate the new delegate
|
|
*/
|
|
- (void)setDelegate:(id <CPAnimationDelegate>)aDelegate
|
|
{
|
|
if (_delegate === aDelegate)
|
|
return;
|
|
|
|
_delegate = aDelegate;
|
|
_implementedDelegateMethods = 0;
|
|
|
|
if ([_delegate respondsToSelector:@selector(animationShouldStart:)])
|
|
_implementedDelegateMethods |= CPAnimationDelegate_animationShouldStart_;
|
|
|
|
if ([_delegate respondsToSelector:@selector(animationDidEnd:)])
|
|
_implementedDelegateMethods |= CPAnimationDelegate_animationDidEnd_;
|
|
|
|
if ([_delegate respondsToSelector:@selector(animationDidStop:)])
|
|
_implementedDelegateMethods |= CPAnimationDelegate_animationDidStop_;
|
|
|
|
if ([_delegate respondsToSelector:@selector(animation:valueForProgress:)])
|
|
_implementedDelegateMethods |= CPAnimationDelegate_animation_valueForProgress_;
|
|
}
|
|
|
|
/*!
|
|
Starts the animation. The method calls \c -animationShouldStart:
|
|
on the delegate (if it implements it) to see if the animation
|
|
should begin.
|
|
*/
|
|
- (void)startAnimation
|
|
{
|
|
// If we're already animating, or our delegate stops us, animate.
|
|
if (_timer || ![self _sendDelegateAnimationShouldStart])
|
|
return;
|
|
|
|
if (_progress === 1.0)
|
|
_progress = 0.0;
|
|
|
|
ACTUAL_FRAME_RATE = 0;
|
|
_lastTime = new Date();
|
|
|
|
var timerInterval = _frameRate <= 0.0 ? 0.0001 : 1.0 / _frameRate;
|
|
|
|
_timer = [CPTimer scheduledTimerWithTimeInterval:timerInterval target:self selector:@selector(animationTimerDidFire:) userInfo:nil repeats:YES];
|
|
}
|
|
|
|
/*
|
|
@ignore
|
|
*/
|
|
- (void)animationTimerDidFire:(CPTimer)aTimer
|
|
{
|
|
var currentTime = new Date(),
|
|
progress = MIN(1.0, [self currentProgress] + (currentTime - _lastTime) / (_duration * 1000.0));
|
|
|
|
_lastTime = currentTime;
|
|
|
|
++ACTUAL_FRAME_RATE;
|
|
|
|
[self setCurrentProgress:progress];
|
|
|
|
if (progress === 1.0)
|
|
{
|
|
[_timer invalidate];
|
|
_timer = nil;
|
|
|
|
[self _sendDelegateAnimationDidEnd];
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Stops the animation before it has completed.
|
|
*/
|
|
- (void)stopAnimation
|
|
{
|
|
if (!_timer)
|
|
return;
|
|
|
|
[_timer invalidate];
|
|
_timer = nil;
|
|
|
|
[self _sendDelegateAnimationDidStop];
|
|
}
|
|
|
|
/*!
|
|
Returns \c YES if the animation
|
|
is running.
|
|
*/
|
|
- (BOOL)isAnimating
|
|
{
|
|
return _timer;
|
|
}
|
|
|
|
/*!
|
|
Sets the animation's progress.
|
|
@param aProgress the animation's progress
|
|
*/
|
|
- (void)setCurrentProgress:(float)aProgress
|
|
{
|
|
_progress = aProgress;
|
|
}
|
|
|
|
/*!
|
|
Returns the animation's progress
|
|
*/
|
|
- (float)currentProgress
|
|
{
|
|
return _progress;
|
|
}
|
|
|
|
/*!
|
|
Returns the animation's timing progress.
|
|
*/
|
|
- (float)currentValue
|
|
{
|
|
var t = [self currentProgress];
|
|
|
|
if ([self _delegateRespondsToAnimationValueForProgress])
|
|
return [self _sendDelegateAnimationValueForProgress:t];
|
|
|
|
if (_animationCurve == CPAnimationLinear)
|
|
return t;
|
|
|
|
var c1 = [],
|
|
c2 = [];
|
|
|
|
[_timingFunction getControlPointAtIndex:1 values:c1];
|
|
[_timingFunction getControlPointAtIndex:2 values:c2];
|
|
|
|
return CubicBezierAtTime(t, c1[0], c1[1], c2[0], c2[1], _duration);
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@implementation CPAnimation (CPAnimationDelegate)
|
|
|
|
/*!
|
|
@ignore
|
|
Check if the delegate responds to animation:valueForProgress:
|
|
*/
|
|
- (BOOL)_delegateRespondsToAnimationValueForProgress
|
|
{
|
|
return _implementedDelegateMethods & CPAnimationDelegate_animation_valueForProgress_;
|
|
}
|
|
|
|
/*!
|
|
@ignore
|
|
Call delegate animationShouldStart:
|
|
*/
|
|
- (BOOL)_sendDelegateAnimationShouldStart
|
|
{
|
|
if (!(_implementedDelegateMethods & CPAnimationDelegate_animationShouldStart_))
|
|
return YES;
|
|
|
|
return [_delegate animationShouldStart:self];
|
|
}
|
|
|
|
/*!
|
|
@ignore
|
|
Call delegate animation:valueForProgress:
|
|
*/
|
|
- (float)_sendDelegateAnimationValueForProgress:(float)aProgress
|
|
{
|
|
if (!(_implementedDelegateMethods & CPAnimationDelegate_animation_valueForProgress_))
|
|
return aProgress;
|
|
|
|
return [_delegate animation:self valueForProgress:aProgress];
|
|
}
|
|
|
|
/*!
|
|
@ignore
|
|
Call delegate animationDidEnd:
|
|
*/
|
|
- (void)_sendDelegateAnimationDidEnd
|
|
{
|
|
if (!(_implementedDelegateMethods & CPAnimationDelegate_animationDidEnd_))
|
|
return;
|
|
|
|
[_delegate animationDidEnd:self];
|
|
}
|
|
|
|
/*!
|
|
@ignore
|
|
Call delegate animationDidStop:
|
|
*/
|
|
- (void)_sendDelegateAnimationDidStop
|
|
{
|
|
if (!(_implementedDelegateMethods & CPAnimationDelegate_animationDidStop_))
|
|
return;
|
|
|
|
[_delegate animationDidStop:self];
|
|
}
|
|
|
|
@end
|
|
|
|
// currently used function to determine time
|
|
// 1:1 conversion to js from webkit source files
|
|
// UnitBezier.h, WebCore_animation_AnimationBase.cpp
|
|
var CubicBezierAtTime = function(t, p1x, p1y, p2x, p2y, duration)
|
|
{
|
|
var ax = 0,
|
|
bx = 0,
|
|
cx = 0,
|
|
ay = 0,
|
|
by = 0,
|
|
cy = 0;
|
|
// `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
|
|
function sampleCurveX(t)
|
|
{
|
|
return ((ax * t + bx) * t + cx) * t;
|
|
}
|
|
|
|
function sampleCurveY(t)
|
|
{
|
|
return ((ay * t + by) * t + cy) * t;
|
|
}
|
|
|
|
function sampleCurveDerivativeX(t)
|
|
{
|
|
return (3.0 * ax * t + 2.0 * bx) * t + cx;
|
|
}
|
|
|
|
// The epsilon value to pass given that the animation is going to run over |duration| seconds. The longer the animation, the more precision is needed in the timing function result to avoid ugly discontinuities.
|
|
function solveEpsilon(duration)
|
|
{
|
|
return 1.0 / (200.0 * duration);
|
|
}
|
|
|
|
function solve(x, epsilon)
|
|
{
|
|
return sampleCurveY(solveCurveX(x, epsilon));
|
|
}
|
|
|
|
// Given an x value, find a parametric value it came from.
|
|
function solveCurveX(x, epsilon)
|
|
{
|
|
var t0,
|
|
t1,
|
|
t2 = x,
|
|
x2,
|
|
d2,
|
|
i = 0;
|
|
|
|
// First try a few iterations of Newton's method -- normally very fast.
|
|
for (; i < 8; i++)
|
|
{
|
|
x2 = sampleCurveX(t2) - x;
|
|
|
|
if (ABS(x2) < epsilon)
|
|
return t2;
|
|
|
|
d2 = sampleCurveDerivativeX(t2);
|
|
|
|
if (ABS(d2) < 1e-6)
|
|
break;
|
|
|
|
t2 = t2 - x2 / d2;
|
|
}
|
|
|
|
// Fall back to the bisection method for reliability.
|
|
t0 = 0.0;
|
|
t1 = 1.0;
|
|
t2 = x;
|
|
|
|
if (t2 < t0)
|
|
return t0;
|
|
|
|
if (t2 > t1)
|
|
return t1;
|
|
|
|
while (t0 < t1)
|
|
{
|
|
x2 = sampleCurveX(t2);
|
|
|
|
if (ABS(x2 - x) < epsilon)
|
|
return t2;
|
|
|
|
if (x > x2)
|
|
t0 = t2;
|
|
|
|
else
|
|
t1 = t2;
|
|
|
|
t2 = (t1 - t0) * 0.5 + t0;
|
|
}
|
|
|
|
return t2; // Failure.
|
|
};
|
|
// Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
|
|
cx = 3.0 * p1x;
|
|
bx = 3.0 * (p2x - p1x) - cx;
|
|
ax = 1.0 - cx - bx;
|
|
cy = 3.0 * p1y;
|
|
by = 3.0 * (p2y - p1y) - cy;
|
|
ay = 1.0 - cy - by;
|
|
|
|
// Convert from input time to parametric value in curve, then from that to output time.
|
|
return solve(t, solveEpsilon(duration));
|
|
};
|