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