typescript-closure-tools
Version:
Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files
248 lines (208 loc) • 7.89 kB
TypeScript
/// <reference path="../../../globals.d.ts" />
/// <reference path="./transitionbase.d.ts" />
/// <reference path="./anim/anim.d.ts" />
/// <reference path="./transition.d.ts" />
/// <reference path="../events/event.d.ts" />
declare module goog.fx {
class Animation extends Animation__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Animation__Class extends goog.fx.TransitionBase__Class implements goog.fx.anim.Animated, goog.fx.Transition {
/**
* Constructor for an animation object.
* @param {Array.<number>} start Array for start coordinates.
* @param {Array.<number>} end Array for end coordinates.
* @param {number} duration Length of animation in milliseconds.
* @param {Function=} opt_acc Acceleration function, returns 0-1 for inputs 0-1.
* @constructor
* @implements {goog.fx.anim.Animated}
* @implements {goog.fx.Transition}
* @extends {goog.fx.TransitionBase}
*/
constructor(start: number[], end: number[], duration: number, opt_acc?: Function);
/**
* Start point.
* @type {Array.<number>}
* @protected
*/
startPoint: number[];
/**
* End point.
* @type {Array.<number>}
* @protected
*/
endPoint: number[];
/**
* Duration of animation in milliseconds.
* @type {number}
* @protected
*/
duration: number;
/**
* Current coordinate for animation.
* @type {Array.<number>}
* @protected
*/
coords: number[];
/**
* Sets whether the animation should use "right" rather than "left" to position
* elements. This is a temporary flag to allow clients to transition
* to the new component at their convenience. At some point "right" will be
* used for RTL elements by default.
* @param {boolean} useRightPositioningForRtl True if "right" should be used for
* positioning, false if "left" should be used for positioning.
*/
enableRightPositioningForRtl(useRightPositioningForRtl: boolean): void;
/**
* Whether the animation should use "right" rather than "left" to position
* elements. This is a temporary flag to allow clients to transition
* to the new component at their convenience. At some point "right" will be
* used for RTL elements by default.
* @return {boolean} True if "right" should be used for positioning, false if
* "left" should be used for positioning.
*/
isRightPositioningForRtlEnabled(): boolean;
/**
* Percent of the way through the animation.
* @type {number}
* @protected
*/
progress: number;
/**
* Timestamp for when last frame was run.
* @type {?number}
* @protected
*/
lastFrame: number;
/**
* @return {number} The current progress of the animation, the number
* is between 0 and 1 inclusive.
*/
getProgress(): number;
/**
* Sets the progress of the animation.
* @param {number} progress The new progress of the animation.
*/
setProgress(progress: number): void;
/**
* Stops an animation, fires a 'destroy' event and then removes all the event
* handlers to clean up memory.
* @deprecated Use dispose() instead.
*/
destroy(): void;
/**
* Handles the actual iteration of the animation in a timeout
* @param {number} now The current time.
*/
cycle(now: number): void;
/**
* Dispatches the ANIMATE event. Sub classes should override this instead
* of listening to the event.
* @protected
*/
onAnimate(): void;
/**
* Dispatches the DESTROY event. Sub classes should override this instead
* of listening to the event.
* @protected
*/
onDestroy(): void;
/**
* Function called when a frame is requested for the animation.
*
* @param {number} now Current time in milliseconds.
*/
onAnimationFrame(now: number): void;
/**
* Plays the transition.
*/
play: any /*missing*/;
/**
* Stops the transition.
*/
stop: any /*missing*/;
}
class AnimationEvent extends AnimationEvent__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class AnimationEvent__Class extends goog.events.Event__Class {
/**
* Class for an animation event object.
* @param {string} type Event type.
* @param {goog.fx.Animation} anim An animation object.
* @constructor
* @extends {goog.events.Event}
*/
constructor(type: string, anim: goog.fx.Animation);
/**
* The current coordinates.
* @type {Array.<number>}
*/
coords: number[];
/**
* The x coordinate.
* @type {number}
*/
x: number;
/**
* The y coordinate.
* @type {number}
*/
y: number;
/**
* The z coordinate.
* @type {number}
*/
z: number;
/**
* The current duration.
* @type {number}
*/
duration: number;
/**
* The current progress.
* @type {number}
*/
progress: number;
/**
* Frames per second so far.
*/
fps: any /*missing*/;
/**
* The state of the animation.
* @type {number}
*/
state: number;
/**
* The animation object.
* @type {goog.fx.Animation}
*/
anim: goog.fx.Animation;
/**
* Returns the coordinates as integers (rounded to nearest integer).
* @return {!Array.<number>} An array of the coordinates rounded to
* the nearest integer.
*/
coordsAsInts(): number[];
}
}
declare module goog.fx.Animation {
/**
* Events fired by the animation.
* @enum {string}
*/
enum EventType { PLAY, BEGIN, RESUME, END, STOP, FINISH, PAUSE, ANIMATE, DESTROY }
/**
* @deprecated Use goog.fx.anim.TIMEOUT.
*/
var TIMEOUT: any /*missing*/;
/**
* Enum for the possible states of an animation.
* @deprecated Use goog.fx.Transition.State instead.
* @enum {number}
*/
enum State { STOPPED, PAUSED, PLAYING }
/**
* @deprecated Use goog.fx.anim.setAnimationWindow.
* @param {Window} animationWindow The window in which to animate elements.
*/
function setAnimationWindow(animationWindow: Window): void;
}