/**@class android.widget.OverScroller
@extends java.lang.Object

 This class encapsulates scrolling with the ability to overshoot the bounds
 of a scrolling operation. This class is a drop-in replacement for
 {@link android.widget.Scroller} in most cases.
*/
var OverScroller = {

/**The amount of friction applied to flings. The default value
 is {@link ViewConfiguration#getScrollFriction}.
@param {Number} friction A scalar dimension-less value representing the coefficient of
         friction.
*/
setFriction : function(  ) {},

/**Returns whether the scroller has finished scrolling.
@return {Boolean} True if the scroller has finished scrolling, false otherwise.
*/
isFinished : function(  ) {},

/**Force the finished field to a particular value. Contrary to
 {@link #abortAnimation}(), forcing the animation to finished
 does NOT cause the scroller to move to the final x and y
 position.
@param {Boolean} finished The new finished value.
*/
forceFinished : function(  ) {},

/**Returns the current X offset in the scroll.
@return {Number} The new X offset as an absolute distance from the origin.
*/
getCurrX : function(  ) {},

/**Returns the current Y offset in the scroll.
@return {Number} The new Y offset as an absolute distance from the origin.
*/
getCurrY : function(  ) {},

/**Returns the absolute value of the current velocity.
@return {Number} The original velocity less the deceleration, norm of the X and Y velocity vector.
*/
getCurrVelocity : function(  ) {},

/**Returns the start X offset in the scroll.
@return {Number} The start X offset as an absolute distance from the origin.
*/
getStartX : function(  ) {},

/**Returns the start Y offset in the scroll.
@return {Number} The start Y offset as an absolute distance from the origin.
*/
getStartY : function(  ) {},

/**Returns where the scroll will end. Valid only for "fling" scrolls.
@return {Number} The final X offset as an absolute distance from the origin.
*/
getFinalX : function(  ) {},

/**Returns where the scroll will end. Valid only for "fling" scrolls.
@return {Number} The final Y offset as an absolute distance from the origin.
*/
getFinalY : function(  ) {},

/**Returns how long the scroll event will take, in milliseconds.
@return {Number} The duration of the scroll in milliseconds.
@hide Pending removal once nothing depends on it
@deprecated OverScrollers don't necessarily have a fixed duration.
             This function will lie to the best of its ability.
*/
getDuration : function(  ) {},

/**Extend the scroll animation. This allows a running animation to scroll
 further and longer, when used with {@link #setFinalX}(int) or {@link #setFinalY}(int).
@param {Number} extend Additional time to scroll in milliseconds.
@see #setFinalX(int)
@see #setFinalY(int)
@hide Pending removal once nothing depends on it
@deprecated OverScrollers don't necessarily have a fixed duration.
             Instead of setting a new final position and extending
             the duration of an existing scroll, use startScroll
             to begin a new animation.
*/
extendDuration : function(  ) {},

/**Sets the final position (X) for this scroller.
@param {Number} newX The new X offset as an absolute distance from the origin.
@see #extendDuration(int)
@see #setFinalY(int)
@hide Pending removal once nothing depends on it
@deprecated OverScroller's final position may change during an animation.
             Instead of setting a new final position and extending
             the duration of an existing scroll, use startScroll
             to begin a new animation.
*/
setFinalX : function(  ) {},

/**Sets the final position (Y) for this scroller.
@param {Number} newY The new Y offset as an absolute distance from the origin.
@see #extendDuration(int)
@see #setFinalX(int)
@hide Pending removal once nothing depends on it
@deprecated OverScroller's final position may change during an animation.
             Instead of setting a new final position and extending
             the duration of an existing scroll, use startScroll
             to begin a new animation.
*/
setFinalY : function(  ) {},

/**Call this when you want to know the new location. If it returns true, the
 animation is not yet finished.
*/
computeScrollOffset : function(  ) {},

/**Start scrolling by providing a starting point and the distance to travel.
 The scroll will use the default value of 250 milliseconds for the
 duration.
@param {Number} startX Starting horizontal scroll offset in pixels. Positive
        numbers will scroll the content to the left.
@param {Number} startY Starting vertical scroll offset in pixels. Positive numbers
        will scroll the content up.
@param {Number} dx Horizontal distance to travel. Positive numbers will scroll the
        content to the left.
@param {Number} dy Vertical distance to travel. Positive numbers will scroll the
        content up.
*/
startScroll : function(  ) {},

/**Start scrolling by providing a starting point and the distance to travel.
@param {Number} startX Starting horizontal scroll offset in pixels. Positive
        numbers will scroll the content to the left.
@param {Number} startY Starting vertical scroll offset in pixels. Positive numbers
        will scroll the content up.
@param {Number} dx Horizontal distance to travel. Positive numbers will scroll the
        content to the left.
@param {Number} dy Vertical distance to travel. Positive numbers will scroll the
        content up.
@param {Number} duration Duration of the scroll in milliseconds.
*/
startScroll : function(  ) {},

/**Call this when you want to 'spring back' into a valid coordinate range.
@param {Number} startX Starting X coordinate
@param {Number} startY Starting Y coordinate
@param {Number} minX Minimum valid X value
@param {Number} maxX Maximum valid X value
@param {Number} minY Minimum valid Y value
@param {Number} maxY Minimum valid Y value
@return {Boolean} true if a springback was initiated, false if startX and startY were
          already within the valid range.
*/
springBack : function(  ) {},

/**
*/
fling : function(  ) {},

/**Start scrolling based on a fling gesture. The distance traveled will
 depend on the initial velocity of the fling.
@param {Number} startX Starting point of the scroll (X)
@param {Number} startY Starting point of the scroll (Y)
@param {Number} velocityX Initial velocity of the fling (X) measured in pixels per
            second.
@param {Number} velocityY Initial velocity of the fling (Y) measured in pixels per
            second
@param {Number} minX Minimum X value. The scroller will not scroll past this point
            unless overX > 0. If overfling is allowed, it will use minX as
            a springback boundary.
@param {Number} maxX Maximum X value. The scroller will not scroll past this point
            unless overX > 0. If overfling is allowed, it will use maxX as
            a springback boundary.
@param {Number} minY Minimum Y value. The scroller will not scroll past this point
            unless overY > 0. If overfling is allowed, it will use minY as
            a springback boundary.
@param {Number} maxY Maximum Y value. The scroller will not scroll past this point
            unless overY > 0. If overfling is allowed, it will use maxY as
            a springback boundary.
@param {Number} overX Overfling range. If > 0, horizontal overfling in either
            direction will be possible.
@param {Number} overY Overfling range. If > 0, vertical overfling in either
            direction will be possible.
*/
fling : function(  ) {},

/**Notify the scroller that we've reached a horizontal boundary.
 Normally the information to handle this will already be known
 when the animation is started, such as in a call to one of the
 fling functions. However there are cases where this cannot be known
 in advance. This function will transition the current motion and
 animate from startX to finalX as appropriate.
@param {Number} startX Starting/current X position
@param {Number} finalX Desired final X position
@param {Number} overX Magnitude of overscroll allowed. This should be the maximum
              desired distance from finalX. Absolute value - must be positive.
*/
notifyHorizontalEdgeReached : function(  ) {},

/**Notify the scroller that we've reached a vertical boundary.
 Normally the information to handle this will already be known
 when the animation is started, such as in a call to one of the
 fling functions. However there are cases where this cannot be known
 in advance. This function will animate a parabolic motion from
 startY to finalY.
@param {Number} startY Starting/current Y position
@param {Number} finalY Desired final Y position
@param {Number} overY Magnitude of overscroll allowed. This should be the maximum
              desired distance from finalY. Absolute value - must be positive.
*/
notifyVerticalEdgeReached : function(  ) {},

/**Returns whether the current Scroller is currently returning to a valid position.
 Valid bounds were provided by the
 {@link #fling(int, int, int, int, int, int, int, int, int, int)} method.

 One should check this value before calling
 {@link #startScroll(int, int, int, int)} as the interpolation currently in progress
 to restore a valid position will then be stopped. The caller has to take into account
 the fact that the started scroll will start from an overscrolled position.
@return {Boolean} true when the current position is overscrolled and in the process of
         interpolating back to a valid value.
*/
isOverScrolled : function(  ) {},

/**Stops the animation. Contrary to {@link #forceFinished}(boolean),
 aborting the animating causes the scroller to move to the final x and y
 positions.
@see #forceFinished(boolean)
*/
abortAnimation : function(  ) {},

/**Returns the time elapsed since the beginning of the scrolling.
@return {Number} The elapsed time in milliseconds.
@hide 
*/
timePassed : function(  ) {},

/**
@hide 
*/
isScrollingInDirection : function(  ) {},


};