dojo/Stateful.js

  • Provides:

    • dojo.Stateful

  • dojo.Stateful

    • type
      Function
    • summary
      Base class for objects that provide named properties with optional getter/setter
control and the ability to watch for property changes
    • example
      
	var obj = new dojo.Stateful();
	obj.watch("foo", function(){
		console.log("foo changed to " + this.get("foo"));
	});
	obj.set("foo","bar");

  • dojo.Stateful.postscript

    • type
      Function
    • parameters:
      • mixin: (typeof )
    • source: [view]
        if(mixin){
         dojo.mixin(this, mixin);
        }
    • summary
  • dojo.Stateful.get
       
    • type
      Function
    • parameters: 
      • name: (typeof String)
        The property to get.
    • source: [view] 
                    
      

                      return this[name];
                    
      
                    
    • summary
      Get a property on a Stateful instance.
    • description
      Get a named property on a Stateful object. The property may
potentially be retrieved via a getter method in subclasses. In the base class
this just retrieves the object's property.
For example:

	stateful = new dojo.Stateful({foo: 3});
	stateful.get("foo") // returns 3
	stateful.foo // returns 3
  • dojo.Stateful.set
       
    • type
      Function
    • parameters: 
      • name: (typeof String)
        The property to set.
      • value: (typeof Object)
        The value to set in the property.
    • source: [view] 
                    
      

                      if(typeof name === "object"){
         for(var x in name){
          this.set(x, name[x]);
         }
         return this;
        }
        var oldValue = this[name];
        this[name] = value;
        if(this._watchCallbacks){
         this._watchCallbacks(name, oldValue, value);
        }
        return this;
                    
      
                    
    • summary
      Set a property on a Stateful instance
    • description
      Sets named properties on a stateful object and notifies any watchers of
the property. A programmatic setter may be defined in subclasses.
For example:

	stateful = new dojo.Stateful();
	stateful.watch(function(name, oldValue, value){
		// this will be called on the set below
	}
	stateful.set(foo, 5);


set() may also be called with a hash of name/value pairs, ex:
	myObj.set({
		foo: "Howdy",
		bar: 3
	})
This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
  • dojo.Stateful.watch
       
    • type
      Function
    • parameters: 
      • name: (typeof String)
        Indicates the property to watch. This is optional (the callback may be the
only parameter), and if omitted, all the properties will be watched
      • callback: (typeof Function)
        The function to execute when the property changes. This will be called after
the property has been changed. The callback will be called with the |this|
set to the instance, the first argument as the name of the property, the
second argument as the old value and the third argument as the new value.
    • source: [view] 
                    
      

                      var callbacks = this._watchCallbacks;
        if(!callbacks){
         var self = this;
         callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
          var notify = function(propertyCallbacks){
           if(propertyCallbacks){
                              propertyCallbacks = propertyCallbacks.slice();
            for(var i = 0, l = propertyCallbacks.length; i < l; i++){
             try{
              propertyCallbacks[i].call(self, name, oldValue, value);
             }catch(e){
              console.error(e);
             }
            }
           }
          };
          notify(callbacks['_' + name]);
          if(!ignoreCatchall){
           notify(callbacks["*"]); // the catch-all
          }
         }; // we use a function instead of an object so it will be ignored by JSON conversion
        }
        if(!callback && typeof name === "function"){
         callback = name;
         name = "*";
        }else{
         // prepend with dash to prevent name conflicts with function (like "name" property)
         name = '_' + name;
        }
        var propertyCallbacks = callbacks[name];
        if(typeof propertyCallbacks !== "object"){
         propertyCallbacks = callbacks[name] = [];
        }
        propertyCallbacks.push(callback);
        return {
         unwatch: function(){
          propertyCallbacks.splice(dojo.indexOf(propertyCallbacks, callback), 1);
         }
        };
                    
      
                    
    • summary
      Watches a property for changes
    • return_summary
      An object handle for the watch. The unwatch method of this object
can be used to discontinue watching this property:

	var watchHandle = obj.watch("foo", callback);
	watchHandle.unwatch(); // callback won't be called now
  • dojo.Stateful._watchCallbacks
       
    • summary
  • dojo.Stateful.watch._watchCallbacks
       
    • type
      Function
    • parameters: 
      • name: (typeof )
      • oldValue: (typeof )
      • value: (typeof )
      • ignoreCatchall: (typeof )
    • source: [view] 
                    
      

                        var notify = function(propertyCallbacks){
           if(propertyCallbacks){
                              propertyCallbacks = propertyCallbacks.slice();
            for(var i = 0, l = propertyCallbacks.length; i < l; i++){
             try{
              propertyCallbacks[i].call(self, name, oldValue, value);
             }catch(e){
              console.error(e);
             }
            }
           }
          };
          notify(callbacks['_' + name]);
          if(!ignoreCatchall){
           notify(callbacks["*"]); // the catch-all
          }
                    
      
                    
    • summary
  • callbacks
       
    • ?? aliases = dojo.Stateful.watch._watchCallbacks (debug: string) ??
    • summary
  • this
       
    • mixins: 
      • mixin: (normal)
    • summary
  • dojo
       
    • type
      Object
    • summary