Clear Up
SharpKit Reference

TaskManager Class

A static Ext.util.TaskRunner instance that can be used to start and stop arbitrary tasks. See 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 start method for details about how to configure a task object.

Namespace: Ext

Constructors

Name Description
TaskManager(object) Parameters
  • interval : Number/Object (optional)

    The minimum precision in milliseconds supported by this TaskRunner instance. Alternatively, a config object to apply to the new instance.

    Defaults to: 10

  • TaskManager(TaskManagerConfig)
    TaskManager(Object[])

    Methods

    Name Description
    callOverridden(object) Call the original method that was previously overridden with override
      Ext.define('My.Cat', {
                constructor: function() {
                alert("I'm a cat!");
                }
                });
                My.Cat.override({
                constructor: function() {
                alert("I'm going to be a cat!");
                this.callOverridden();
                alert("Meeeeoooowwww");
                }
                });
                var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                // alerts "I'm a cat!"
                // alerts "Meeeeoooowwww"
                

    This method has been deprecated

    as of 4.1. Use callParent instead.

    callParent(object) Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext.define).
      Ext.define('My.Base', {
                constructor: function (x) {
                this.x = x;
                },
                statics: {
                method: function (x) {
                return x;
                }
                }
                });
                Ext.define('My.Derived', {
                extend: 'My.Base',
                constructor: function () {
                this.callParent([21]);
                }
                });
                var obj = new My.Derived();
                alert(obj.x);  // alerts 21
                
    This can be used with an override as follows:
      Ext.define('My.DerivedOverride', {
                override: 'My.Derived',
                constructor: function (x) {
                this.callParent([x*2]); // calls original My.Derived constructor
                }
                });
                var obj = new My.Derived();
                alert(obj.x);  // now alerts 42
                
    This also works with static methods.
      Ext.define('My.Derived2', {
                extend: 'My.Base',
                statics: {
                method: function (x) {
                return this.callParent([x*2]); // calls My.Base.method
                }
                }
                });
                alert(My.Base.method(10);     // alerts 10
                alert(My.Derived2.method(10); // alerts 20
                
    Lastly, it also works with overridden static methods.
      Ext.define('My.Derived2Override', {
                override: 'My.Derived2',
                statics: {
                method: function (x) {
                return this.callParent([x*2]); // calls My.Derived2.method
                }
                }
                });
                alert(My.Derived2.method(10); // now alerts 40
                
    destroy() Destroys this instance, stopping all tasks that are currently running. Overrides: Ext.Base.destroy
    getInitialConfig(object) Returns the initial configuration passed to constructor when instantiating this class.
    initConfig(object) Initialize configuration for this class. a typical example:
      Ext.define('My.awesome.Class', {
                // The default config
                config: {
                name: 'Awesome',
                isAwesome: true
                },
                constructor: function(config) {
                this.initConfig(config);
                }
                });
                var awesome = new My.awesome.Class({
                name: 'Super Awesome'
                });
                alert(awesome.getName()); // 'Super Awesome'
                
    newTask(object) Creates a new Task instance. These instances can be easily started and stopped.
    start(object) 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 stop method.
    statics() Get the reference to the class from which this object was instantiated. Note that unlike self, this.statics() is scope-independent and it always returns the class from which it was called, regardless of what this points to during run-time
      Ext.define('My.Cat', {
                statics: {
                totalCreated: 0,
                speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
                },
                constructor: function() {
                var statics = this.statics();
                alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
                // equivalent to: My.Cat.speciesName
                alert(this.self.speciesName);   // dependent on 'this'
                statics.totalCreated++;
                },
                clone: function() {
                var cloned = new this.self;                      // dependent on 'this'
                cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
                return cloned;
                }
                });
                Ext.define('My.SnowLeopard', {
                extend: 'My.Cat',
                statics: {
                speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
                },
                constructor: function() {
                this.callParent();
                }
                });
                var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
                var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
                var clone = snowLeopard.clone();
                alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
                alert(clone.groupName);                 // alerts 'Cat'
                alert(My.Cat.totalCreated);             // alerts 3
                
    stop(object) Stops an existing running task.
    stopAll() Stops all tasks that are currently running.

    Fields

    Name Description
    interval The timer resolution. Defaults to: 10
    © Copyright 2005-2011 SharpKit. All rights reserved.