@flashport/flashport

/** * Tweener * Transition controller for movieclips, sounds, textfields and other objects * * @author Zeh Fernando, Nate Chatellier, Arthur Debert, Francis Turmel * @version 1.33.74 */ export declare class Tweener { private static _mainTimeline; private static __tweener_controller__; private static _engineExists; private static _inited; private static _currentTime; private static _currentTimeFrame; private static _tweenList; private static _timeScale; private static _transitionList; private static _specialPropertyList; private static _specialPropertyModifierList; private static _specialPropertySplitterList; static autoOverwrite: boolean; /** * There's no constructor. * @private */ constructor(); /** * Adds a new tweening. * * @param (first-n param) Object Object that should be tweened: a movieclip, textfield, etc.. OR an array of objects * @param (last param) Object Object containing the specified parameters in any order, as well as the properties that should be tweened and their values * @param .time Number Time in seconds or frames for the tweening to take (defaults 2) * @param .delay Number Delay time (defaults 0) * @param .useFrames Boolean Whether to use frames instead of seconds for time control (defaults false) * @param .transition String/Function Type of transition equation... (defaults to "easeoutexpo") * @param .onStart Function * Direct property, See the TweenListObj class * @param .onUpdate Function * Direct property, See the TweenListObj class * @param .onComplete Function * Direct property, See the TweenListObj class * @param .onOverwrite Function * Direct property, See the TweenListObj class * @param .onStartParams Array * Direct property, See the TweenListObj class * @param .onUpdateParams Array * Direct property, See the TweenListObj class * @param .onCompleteParams Array * Direct property, See the TweenListObj class * @param .onOverwriteParams Array * Direct property, See the TweenListObj class * @param .rounded Boolean * Direct property, See the TweenListObj class * @param .skipUpdates Number * Direct property, See the TweenListObj class * @return Boolean TRUE if the tween was successfully added, FALSE if otherwise */ static addTween: (p_scopes?: any, p_parameters?: any) => boolean; /** * Adds a new caller tweening. * * @param (first-n param) Object that should be tweened: a movieclip, textfield, etc.. OR an array of objects * @param (last param) Object containing the specified parameters in any order, as well as the properties that should be tweened and their values * @param .time Number Time in seconds or frames for the tweening to take (defaults 2) * @param .delay Number Delay time (defaults 0) * @param .count Number Number of times this caller should be called * @param .transition String/Function Type of transition equation... (defaults to "easeoutexpo") * @param .onStart Function Event called when tween starts * @param .onUpdate Function Event called when tween updates * @param .onComplete Function Event called when tween ends * @param .waitFrames Boolean Whether to wait (or not) one frame for each call * @return <code>true</code> if the tween was successfully added, <code>false</code> if otherwise. */ static addCaller: (p_scopes?: any, p_parameters?: any) => boolean; /** * Remove an specified tweening of a specified object the tweening list, if it conflicts with the given time. * * @param p_scope Object List of objects affected * @param p_properties Object List of properties affected (PropertyInfoObj instances) * @param p_timeStart Number Time when the new tween starts * @param p_timeComplete Number Time when the new tween ends * @return Boolean Whether or not it actually deleted something */ static removeTweensByTime: (p_scope: any, p_properties: any, p_timeStart: number, p_timeComplete: number) => boolean; /** * Remove tweenings from a given object from the tweening list. * * @param p_tween Object Object that must have its tweens removed * @param (2nd-last params) Object Property(ies) that must be removed * @return Boolean Whether or not it successfully removed this tweening */ static removeTweens: (p_scope: any, ...args: any[]) => boolean; /** * Remove all tweenings from the engine. * * @return <code>true</code> if it successfully removed any tweening, <code>false</code> if otherwise. */ static removeAllTweens: () => boolean; /** * Pause tweenings for a given object. * * @param p_scope Object that must have its tweens paused * @param (2nd-last params) Property(ies) that must be paused * @return <code>true</code> if it successfully paused any tweening, <code>false</code> if otherwise. */ static pauseTweens: (p_scope: any, ...args: any[]) => boolean; /** * Pause all tweenings on the engine. * * @return <code>true</code> if it successfully paused any tweening, <code>false</code> if otherwise. * @see #resumeAllTweens() */ static pauseAllTweens: () => boolean; /** * Resume tweenings from a given object. * * @param p_scope Object Object that must have its tweens resumed * @param (2nd-last params) Object Property(ies) that must be resumed * @return Boolean Whether or not it successfully resumed something */ static resumeTweens: (p_scope: any, ...args: any[]) => boolean; /** * Resume all tweenings on the engine. * * @return <code>true</code> if it successfully resumed any tweening, <code>false</code> if otherwise. * @see #pauseAllTweens() */ static resumeAllTweens: () => boolean; /** * Do some generic action on specific tweenings (pause, resume, remove, more?) * * @param p_function Function Function to run on the tweenings that match * @param p_scope Object Object that must have its tweens affected by the function * @param p_properties Array Array of strings that must be affected * @return Boolean Whether or not it successfully affected something */ private static affectTweens; /** * Splits a tweening in two * * @param p_tween Number Object that must have its tweens split * @param p_properties Array Array of strings containing the list of properties that must be separated * @return Number The index number of the new tween */ static splitTweens: (p_tween: number, p_properties: any[]) => number; /** * Updates all existing tweenings. * * @return Boolean FALSE if no update was made because there's no tweening (even delayed ones) */ private static updateTweens; /** * Remove a specific tweening from the tweening list. * * @param p_tween Number Index of the tween to be removed on the tweenings list * @return Boolean Whether or not it successfully removed this tweening */ static removeTweenByIndex: (i: number, p_finalRemoval?: boolean) => boolean; /** * Pauses a specific tween. * * @param p_tween Number Index of the tween to be paused * @return Boolean Whether or not it successfully paused this tweening */ static pauseTweenByIndex: (p_tween: number) => boolean; /** * Resumes a specific tween. * * @param p_tween Number Index of the tween to be resumed * @return Boolean Whether or not it successfully resumed this tweening */ static resumeTweenByIndex: (p_tween: number) => boolean; /** * Updates a specific tween. * * @param i Number Index (from the tween list) of the tween that should be updated * @return Boolean FALSE if it's already finished and should be deleted, TRUE if otherwise */ private static updateTweenByIndex; /** * Initiates the Tweener--should only be ran once. */ static init: (...rest: any[]) => void; /** * Adds a new function to the available transition list "shortcuts". * * @param p_name String Shorthand transition name * @param p_function Function The proper equation function */ static registerTransition: (p_name: string, p_function: Function) => void; /** * Adds a new special property to the available special property list. * * @param p_name Name of the "special" property. * @param p_getFunction Function that gets the value. * @param p_setFunction Function that sets the value. */ static registerSpecialProperty: (p_name: string, p_getFunction: Function, p_setFunction: Function, p_parameters?: any[], p_preProcessFunction?: Function) => void; /** * Adds a new special property modifier to the available modifier list. * * @param p_name Name of the "special" property modifier. * @param p_modifyFunction Function that modifies the value. * @param p_getFunction Function that gets the value. */ static registerSpecialPropertyModifier: (p_name: string, p_modifyFunction: Function, p_getFunction: Function) => void; /** * Adds a new special property splitter to the available splitter list. * * @param p_name Name of the "special" property splitter. * @param p_splitFunction Function that splits the value. */ static registerSpecialPropertySplitter: (p_name: string, p_splitFunction: Function, p_parameters?: any[]) => void; static setController(main: any): void; /** * Starts the Tweener class engine. It is supposed to be running every time a tween exists. */ private static startEngine; /** * Stops the Tweener class engine. */ private static stopEngine; /** * Updates the time to enforce time grid-based updates. */ static updateTime: () => void; /** * Updates the current frame count */ static updateFrame: () => void; /** * Ran once every frame. It's the main engine; updates all existing tweenings. */ static onEnterFrame: (e: Event) => void; /** * Sets the new time scale. * * @param p_time Number New time scale (0.5 = slow, 1 = normal, 2 = 2x fast forward, etc) */ static setTimeScale: (p_time: number) => void; /** * Finds whether or not an object has any tweening. * * @param p_scope Target object. * @return <code>true</code> if there's a tweening occuring on this object (paused, delayed, or active), <code>false</code> if otherwise. */ static isTweening: (p_scope: any) => boolean; /** * Returns an array containing a list of the properties being tweened for this object. * * @param p_scope Target object. * @return Total number of properties being tweened (including delayed or paused tweens). */ static getTweens: (p_scope: any) => any[]; /** * Returns the number of properties being tweened for a given object. * * @param p_scope Target object. * @return Total number of properties being tweened (including delayed or paused tweens). */ static getTweenCount: (p_scope: any) => number; private static handleError; /** * Get the current tweening time (no matter if it uses frames or time as basis), given a specific tweening * * @param p_tweening TweenListObj Tween information */ static getCurrentTweeningTime: (p_tweening: any) => number; /** * Return the current tweener version * * @return String The number of the current Tweener version */ static getVersion: () => string; /** * Output an error message * * @param p_message String The error message to output */ static printError: (p_message: string) => void; }