FX

    onMouseDragged: function(evt: MouseEvent): Void {
        var dragTime = Duration.valueOf(java.lang.System.currentTimeMillis());
        if (java.lang.Math.abs(evt.dragX) > Constants.FLICK_DRAG_THRESHOLD) {
                            
            // Set the elevator's dragging flag to prevent its
            // overlay from recentering on every mouse event.
                 
            dragging = true;
            position = posAnchor - evt.dragX / (contentWidth - windowWidth);

            // Monitor the dragging speed.
			
            dragSpeed = (evt.dragX - lastDragX) / 
			dragTime.sub(lastDragTime).toMillis();
            
            if (dragSpeed > Constants.FLICK_MAX_SPEED) {
               dragSpeed = Constants.FLICK_MAX_SPEED;
               } else if (dragSpeed < -Constants.FLICK_MAX_SPEED) {
                 dragSpeed = -Constants.FLICK_MAX_SPEED;
               }
               lastDragTime = dragTime;
               lastDragX = evt.dragX;
            }
      }

  flickTimeline = Timeline {
      keyFrames: [
         at (0s) {
           flickOffset => scrollOffset tween flickInterpolator
          },
          KeyFrame {
            time: Duration.valueOf(restTime)
            action: bounce
            values: [
            flickOffset => restOffset tween flickInterpolator
            ]                        
          }
       ];
    };

class FlickInterpolator extends Interpolator {

    // Initial position
    var x0: Number;
			
    // Initial velocity
    var v0: Number;
			
    // The time at which the object comes to rest.
    var t1: Number;
			
    override function interpolate(startValue: java.lang.Object,
             endValue: java.lang.Object,fraction: Number) :   
             java.lang.Object {
			
             // The sign of the acceleration parameter is based on the
			 // direction of motion.
   
             var a : Number = bind if (v0 > 0) {
			 Constants.FLICK_ACCELERATION;
             } else {
             -Constants.FLICK_ACCELERATION;
             }
			   
             // The interpolation always begins at t = 0 so
             // t = t0 + (t1 - t0) * fraction becomes
             // t = t1 * fraction
			        
             var t = fraction * t1;
			
             // Apply the motion formula for constant acceleration.
						   
             return x0 + v0 * t + a * t * t / 2;
    }
}                

    var restOffset = 0.0;
    var a = -Constants.FLICK_ACCELERATION;
    if (scrollOffset <= 0) {
       restOffset = -(contentWidth - windowWidth);
       a *= -1;
    }

    // Compute the initial rebound velocity based on the position and
    // the defined bounce duration.
       
       var v0 = (restOffset - scrollOffset -
       a * Constants.FLICK_BOUNCE_TIME * Constants.FLICK_BOUNCE_TIME / 2) /
       Constants.FLICK_BOUNCE_TIME;

     // Create a motion formula interpolator for the bounce animation.
	 
     var flickInterpolator = FlickInterpolator {
         x0: scrollOffset
         v0: v0
         t1: Constants.FLICK_BOUNCE_TIME;
     }