    /**
     * Provides the ability to execute one or more arbitrary tasks in a asynchronous manner.
     * Generally, you can use the singleton {@link Ext.TaskManager} instead, but if needed,
     * you can create separate instances of TaskRunner. Any number of separate tasks can be
     * started at any time and will run independently of each other.
     *
     * Example usage:
     *
     *      // Start a simple clock task that updates a div once per second
     *      var updateClock = function () {
     *          Ext.fly('clock').update(new Date().format('g:i:s A'));
     *      }
     *
     *      var runner = new Ext.util.TaskRunner();
     *      var task = runner.start({
     *          run: updateClock,
     *          interval: 1000
     *      }
     *
     * The equivalent using TaskManager:
     *
     *      var task = Ext.TaskManager.start({
     *          run: updateClock,
     *          interval: 1000
     *      });
     *
     * To end a running task:
     *
     *      Ext.TaskManager.stop(task);
     *
     * If a task needs to be started and stopped repeated over time, you can create a
     * {@link Ext.util.TaskRunner.Task Task} instance.
     *
     *      var task = runner.newTask({
     *          run: function () {
     *              // useful code
     *          },
     *          interval: 1000
     *      });
     *
     *      task.start();
     *
     *      // ...
     *
     *      task.stop();
     *
     *      // ...
     *
     *      task.start();
     *
     * A re-usable, one-shot task can be managed similar to the above:
     *
     *      var task = runner.newTask({
     *          run: function () {
     *              // useful code to run once
     *          },
     *          repeat: 1
     *      });
     *
     *      task.start();
     *
     *      // ...
     *
     *      task.start();
     *
     * See the {@link #start} method for details about how to configure a task object.
     *
     * Also see {@link Ext.util.DelayedTask}.
     *
     * @constructor
     * @param {Number/Object} [interval=10] The minimum precision in milliseconds supported by this
     * TaskRunner instance. Alternatively, a config object to apply to the new instance.
     */
    Ext.define('Ext.util.TaskRunner', {
        /**
         * @cfg interval
         * The timer resolution.
         */
        interval: 10,

        /**
         * @property timerId
         * The id of the current timer.
         * @private
         */
        timerId: null,

        constructor: function (interval) {
            var me = this;

            if (typeof interval == 'number') {
                me.interval = interval;
            } else if (interval) {
                Ext.apply(me, interval);
            }

            me.tasks = [];
            me.timerFn = Ext.Function.bind(me.onTick, me);
        },

        /**
         * Creates a new {@link Ext.util.TaskRunner.Task Task} instance. These instances can
         * be easily started and stopped.
         * @param {Object} config The config object. For details on the supported properties,
         * see {@link #start}.
         */
        newTask: function (config) {
            var task = new Ext.util.TaskRunner.Task(config);
            task.manager = this;
            return task;
        },

        /**
         * Starts a new task.
         *
         * Before each invocation, Ext injects the property `taskRunCount` into the task object
         * so that calculations based on the repeat count can be performed.
         *
         * The returned task will contain a `destroy` method that can be used to destroy the
         * task and cancel further calls. This is equivalent to the {@link #stop} method.
         *
         * @param {Object} task A config object that supports the following properties:
         * @param {Function} task.run The function to execute each time the task is invoked. The
         * function will be called at each interval and passed the `args` argument if specified,
         * and the current invocation count if not.
         *
         * If a particular scope (`this` reference) is required, be sure to specify it using
         * the `scope` argument.
         *
         * @param {Function} task.onError The function to execute in case of unhandled
         * error on task.run.
         *
         * @param {Boolean} task.run.return `false` from this function to terminate the task.
         *
         * @param {Number} task.interval The frequency in milliseconds with which the task
         * should be invoked.
         *
         * @param {Object[]} task.args An array of arguments to be passed to the function
         * specified by `run`. If not specified, the current invocation count is passed.
         *
         * @param {Object} task.scope The scope (`this` reference) in which to execute the
         * `run` function. Defaults to the task config object.
         *
         * @param {Number} task.duration The length of time in milliseconds to invoke the task
         * before stopping automatically (defaults to indefinite).
         *
         * @param {Number} task.repeat The number of times to invoke the task before stopping
         * automatically (defaults to indefinite).
         * @return {Object} The task
         */
        start: function(task) {
            var me = this,
                now = new Date().getTime();

            if (!task.pending) {
                me.tasks.push(task);
                task.pending = true; // don't allow the task to be added to me.tasks again
            }

            task.stopped = false; // might have been previously stopped...
            task.taskStartTime = now;
            task.taskRunTime = task.fireOnStart !== false ? 0 : task.taskStartTime;
            task.taskRunCount = 0;

            if (!me.firing) {
                if (task.fireOnStart !== false) {
                    me.startTimer(0, now);
                } else {
                    me.startTimer(task.interval, now);
                }
            }

            return task;
        },

        /**
         * Stops an existing running task.
         * @param {Object} task The task to stop
         * @return {Object} The task
         */
        stop: function(task) {
            // NOTE: we don't attempt to remove the task from me.tasks at this point because
            // this could be called from inside a task which would then corrupt the state of
            // the loop in onTick
            if (!task.stopped) {
                task.stopped = true;

                if (task.onStop) {
                    task.onStop.call(task.scope || task, task);
                }
            }

            return task;
        },

        /**
         * Stops all tasks that are currently running.
         */
        stopAll: function() {
            // onTick will take care of cleaning up the mess after this point...
            Ext.each(this.tasks, this.stop, this);
        },

        //-------------------------------------------------------------------------

        firing: false,

        nextExpires: 1e99,

        // private
        onTick: function () {
            var me = this,
                tasks = me.tasks,
                now = new Date().getTime(),
                nextExpires = 1e99,
                len = tasks.length,
                expires, newTasks, i, task, rt, remove;

            me.timerId = null;
            me.firing = true; // ensure we don't startTimer during this loop...

            // tasks.length can be > len if start is called during a task.run call... so we
            // first check len to avoid tasks.length reference but eventually we need to also
            // check tasks.length. we avoid repeating use of tasks.length by setting len at
            // that time (to help the next loop)
            for (i = 0; i < len || i < (len = tasks.length); ++i) {
                task = tasks[i];

                if (!(remove = task.stopped)) {
                    expires = task.taskRunTime + task.interval;

                    if (expires <= now) {
                        rt = 1; // otherwise we have a stale "rt"
                        try {
                            rt = task.run.apply(task.scope || task, task.args || [++task.taskRunCount]);
                        } catch (taskError) {
                            try {
                                if (task.onError) {
                                    rt = task.onError.call(task.scope || task, task, taskError);
                                }
                            } catch (ignore) { }
                        }
                        task.taskRunTime = now;
                        if (rt === false || task.taskRunCount === task.repeat) {
                            me.stop(task);
                            remove = true;
                        } else {
                            remove = task.stopped; // in case stop was called by run
                            expires = now + task.interval;
                        }
                    }

                    if (!remove && task.duration && task.duration <= (now - task.taskStartTime)) {
                        me.stop(task);
                        remove = true;
                    }
                }

                if (remove) {
                    task.pending = false; // allow the task to be added to me.tasks again

                    // once we detect that a task needs to be removed, we copy the tasks that
                    // will carry forward into newTasks... this way we avoid O(N*N) to remove
                    // each task from the tasks array (and ripple the array down) and also the
                    // potentially wasted effort of making a new tasks[] even if all tasks are
                    // going into the next wave.
                    if (!newTasks) {
                        newTasks = tasks.slice(0, i);
                        // we don't set me.tasks here because callbacks can also start tasks,
                        // which get added to me.tasks... so we will visit them in this loop
                        // and account for their expirations in nextExpires...
                    }
                } else {
                    if (newTasks) {
                        newTasks.push(task); // we've cloned the tasks[], so keep this one...
                    }

                    if (nextExpires > expires) {
                        nextExpires = expires; // track the nearest expiration time
                    }
                }
            }

            if (newTasks) {
                // only now can we copy the newTasks to me.tasks since no user callbacks can
                // take place
                me.tasks = newTasks;
            }

            me.firing = false; // we're done, so allow startTimer afterwards

            if (me.tasks.length) {
                // we create a new Date here because all the callbacks could have taken a long
                // time... we want to base the next timeout on the current time (after the
                // callback storm):
                me.startTimer(nextExpires - now, new Date().getTime());
            }
        },

        // private
        startTimer: function (timeout, now) {
            var me = this,
                expires = now + timeout,
                timerId = me.timerId;

            // Check to see if this request is enough in advance of the current timer. If so,
            // we reschedule the timer based on this new expiration.
            if (timerId && me.nextExpires - expires > me.interval) {
                clearTimeout(timerId);
                timerId = null;
            }

            if (!timerId) {
                if (timeout < me.interval) {
                    timeout = me.interval;
                }

                me.timerId = setTimeout(me.timerFn, timeout);
                me.nextExpires = expires;
            }
        }
    },
    function () {
        var me = this,
            proto = me.prototype;

        /**
         * Destroys this instance, stopping all tasks that are currently running.
         * @method destroy
         */
        proto.destroy = proto.stopAll;

        /**
        * @class Ext.TaskManager
        * @extends Ext.util.TaskRunner
        * @singleton
        *
        * A static {@link Ext.util.TaskRunner} instance that can be used to start and stop
        * arbitrary tasks. See {@link Ext.util.TaskRunner} for supported methods and task
        * config properties.
        *
        *    // Start a simple clock task that updates a div once per second
        *    var task = {
        *       run: function(){
        *           Ext.fly('clock').update(new Date().format('g:i:s A'));
        *       },
        *       interval: 1000 //1 second
        *    }
        *
        *    Ext.TaskManager.start(task);
        *
        * See the {@link #start} method for details about how to configure a task object.
        */
        Ext.util.TaskManager = Ext.TaskManager = new me();

        /**
         * Instances of this class are created by {@link Ext.util.TaskRunner#newTask} method.
         *
         * For details on config properties, see {@link Ext.util.TaskRunner#start}.
         * @class Ext.util.TaskRunner.Task
         */
        me.Task = new Ext.Class({
            isTask: true,

            /**
             * This flag is set to `true` by {@link #stop}.
             * @private
             */
            stopped: true, // this avoids the odd combination of !stopped && !pending

            /**
             * Override default behavior
             */
            fireOnStart: false,

            constructor: function (config) {
                Ext.apply(this, config);
            },

            /**
             * Restarts this task, clearing it duration, expiration and run count.
             * @param {Number} [interval] Optionally reset this task's interval.
             */
            restart: function (interval) {
                if (interval !== undefined) {
                    this.interval = interval;
                }

                this.manager.start(this);
            },

            /**
             * Starts this task if it is not already started.
             * @param {Number} [interval] Optionally reset this task's interval.
             */
            start: function (interval) {
                if (this.stopped) {
                    this.restart(interval);
                }
            },

            /**
             * Stops this task.
             */
            stop: function () {
                this.manager.stop(this);
            }
        });

        proto = me.Task.prototype;

        /**
         * Destroys this instance, stopping this task's execution.
         * @method destroy
         */
        proto.destroy = proto.stop;
    });