Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.wire.Wire"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.wire.Wire"] = true;
dojo.provide("dojox.wire.Wire");

dojo.require("dojox.wire._base");

dojo.declare("dojox.wire.Wire", null, {
        //      summary:
        //              A default and base Wire to access an object property
        //      description:
        //              This class accesses a property of an object with a dotted notation
        //              specified to 'property' property, such as "a.b.c", which identifies
        //              a descendant property, "object.a.b.c".
        //              Property names in the dotted notation may have an array index, such
        //              as "a[0]", to identify an array element, literally, "object.a[0]".
        //              When a notation start with an array index, such as "[0].a", it
        //              specifies an array element of the root object (array),
        //              "object[0].a".
        //              This class also serves as a base class for other Wire classes,
        //              preparing a root object and converting a return value, so that
        //              sub-classes just can implement _getValue() and _setValue() called
        //              from getValue() and setValue() implemented by this calss.
        
        _wireClass: "dojox.wire.Wire",
        
        constructor: function(/*Object*/args){
                //      summary:
                //              Initialize properties
                //      description:
                //              If 'converter' property is specified and is a string for
                //              a converter class, an instanceof the converter class is
                //              created.
                //      args:
                //              Arguments to initialize properties
                //              object:
                //                      A root object (or another Wire to access a root object)
                //              property:
                //                      A dotted notation to a descendant property
                //              type:
                //                      A type of the return value (for the source Wire)
                //              converter:
                //                      A converter object (or class name) to convert the return
                //                      value (for the source Wire)
                dojo.mixin(this, args);

                if(this.converter){
                        if(dojo.isString(this.converter)){
                                //First check the object tree for it.  Might be defined variable
                                //name/global function (like a jsId, or just a function name).
                                var convertObject = dojo.getObject(this.converter);
                                if (dojo.isFunction(convertObject)){
                                        //We need to see if this is a pure function or an object constructor...
                                        try{
                                                var testObj = new convertObject();
                                                if(testObj && !dojo.isFunction(testObj["convert"])){
                                                        //Looks like a 'pure' function...
                                                        this.converter = {convert: convertObject};
                                                }else{
                                                        this.converter = testObj;
                                                }
                                        }catch(e){
                                                //Do if this fails.     
                                        }
                                }else if(dojo.isObject(convertObject)){
                                        //It's an object, like a jsId ... see if it has a convert function
                                        if(dojo.isFunction(convertObject["convert"])){
                                                this.converter = convertObject;
                                        }
                                }

                                //No object with that name (Converter is still a string), 
                                //then look for a class that needs to be dynamically loaded...
                                if (dojo.isString(this.converter)) {
                                        var converterClass = dojox.wire._getClass(this.converter);
                                        if(converterClass){
                                                this.converter = new converterClass();
                                        }else{
                                                this.converter = undefined;
                                        }
                                }
                        }else if(dojo.isFunction(this.converter)){
                                this.converter = {convert: this.converter};
                        }
                }
        },

        getValue: function(/*Object||Array*/defaultObject){
                //      summary:
                //              Return a value of an object
                //      description:
                //              This method first determins a root object as follows:
                //              1. If 'object' property specified,
                //              1.1 If 'object' is a Wire, its getValue() method is called to
                //              obtain a root object.
                //              1.2 Otherwise, use 'object' as a root object.
                //              2. Otherwise, use 'defaultObject' argument.
                //              3. If 'property' is specified, it is used to get a property
                //                      value.
                //              Then, if a sub-class implements _getValue() method, it is
                //              called with the root object to get the return value.
                //              Otherwise, the root object (typically, a property valye) is
                //              used for the return value.
                //              Finally, if 'type' property is specified, the return value is
                //              converted to the specified primitive type ("string", "number",
                //              "boolean" and "array").
                //              If 'converter' property is specified, its convert() method is
                //              called to convert the value.
                //      defaultObject:
                //              A default root object
                //      returns:
                //              A value found
                var object = undefined;
                if(dojox.wire.isWire(this.object)){
                        object = this.object.getValue(defaultObject);
                }else{
                        object = (this.object || defaultObject);
                }

                if(this.property){
                        var list = this.property.split('.');
                        for(var i in list){
                                if(!object){
                                        return object; //anything (null, undefined, etc)
                                }
                                object = this._getPropertyValue(object, list[i]);
                        }
                }

                var value = undefined;
                if(this._getValue){
                        value = this._getValue(object);
                }else{
                        value = object;
                }

                if(value){
                        if(this.type){
                                if(this.type == "string"){
                                        value = value.toString();
                                }else if(this.type == "number"){
                                        value = parseInt(value);
                                }else if(this.type == "boolean"){
                                        value = (value != "false");
                                }else if(this.type == "array"){
                                        if(!dojo.isArray(value)){
                                                value = [value];
                                        }
                                }
                        }
                        if(this.converter && this.converter.convert){
                                value = this.converter.convert(value, this); // optional "this" context
                        }
                }
                return value; //anything
        },

        setValue: function(/*anything*/value, /*Object||Array*/defaultObject){
                //      summary:
                //              Set a value to an object
                //      description:
                //              This method first determins a root object as follows:
                //              1. If 'object' property specified,
                //              1.1 If 'object' is a Wire, its getValue() method is called to
                //              obtain a root object.
                //              1.2 Otherwise, use 'object' as a root object.
                //              2. Otherwise, use 'defaultObject' argument.
                //              3. If 'property' is specified, it is used to get a property
                //                      value.
                //              Then, if a sub-class implements _setValue() method, it is
                //              called with the root object and 'value' argument to set
                //              the value.
                //              Otherwise, 'value' is set to a property specified with
                //              'property' property.
                //              If the root object is undefined and 'object' property is a Wire
                //              and a new object is created and returned by _setValue() it is
                //              set through 'object' (setValue() method).
                //      value:
                //              A value to set
                //      defaultObject:
                //              A default root object
                var object = undefined;
                if(dojox.wire.isWire(this.object)){
                        object = this.object.getValue(defaultObject);
                }else{
                        object = (this.object || defaultObject);
                }

                var property = undefined;
                if(this.property){
                        if(!object){
                                if(dojox.wire.isWire(this.object)){
                                        object = {};
                                        this.object.setValue(object, defaultObject);
                                }else{
                                        throw new Error(this._wireClass + ".setValue(): invalid object");
                                }
                        }
                        var list = this.property.split('.');
                        var last = list.length - 1;
                        for(var i = 0; i < last; i++){
                                var p = list[i];
                                var o = this._getPropertyValue(object, p);
                                if(!o){
                                        o = {};
                                        this._setPropertyValue(object, p, o);
                                }
                                object = o;
                        }
                        property = list[last];
                }

                if(this._setValue){
                        if(property){
                                var o = this._getPropertyValue(object, property);
                                if(!o){
                                        o = {};
                                        this._setPropertyValue(object, property, o);
                                }
                                object = o;
                        }
                        var newObject = this._setValue(object, value);
                        if(!object && newObject){
                                if(dojox.wire.isWire(this.object)){
                                        this.object.setValue(newObject, defaultObject);
                                }else{
                                        throw new Error(this._wireClass + ".setValue(): invalid object");
                                }
                        }
                }else{
                        if(property){
                                this._setPropertyValue(object, property, value);
                        }else{
                                if(dojox.wire.isWire(this.object)){
                                        this.object.setValue(value, defaultObject);
                                }else{
                                        throw new Error(this._wireClass + ".setValue(): invalid property");
                                }
                        }
                }
        },

        _getPropertyValue: function(/*Object||Array*/object, /*String*/property){
                //      summary:
                //              Return a property value of an object
                //      description:
                //              A value for 'property' of 'object' is returned.
                //              If 'property' ends with an array index, it is used to indentify
                //              an element of an array property.
                //              If 'object' implements getPropertyValue(), it is called with
                //              'property' to obtain the property value.
                //              If 'object' implements a getter for the property, it is called
                //              to obtain the property value.
                //      object:
                //              A default root object
                //      property:
                //              A property name
                //      returns:
                //              A value found, otherwise 'undefined'
                var value = undefined;
                var i1 = property.indexOf('[');
                if(i1 >= 0){
                        var i2 = property.indexOf(']');
                        var index = property.substring(i1 + 1, i2);
                        var array = null;
                        if(i1 === 0){ // object is array
                                array = object;
                        }else{
                                property = property.substring(0, i1);
                                array = this._getPropertyValue(object, property);
                                if(array && !dojo.isArray(array)){
                                        array = [array];
                                }
                        }
                        if(array){
                                value = array[index];
                        }
                }else if(object.getPropertyValue){
                        value = object.getPropertyValue(property);
                }else{
                        var getter = "get" + property.charAt(0).toUpperCase() + property.substring(1);
                        if(object[getter]){
                                value = object[getter]();
                        }else{
                                value = object[property];
                        }
                }
                return value; //anything
        },

        _setPropertyValue: function(/*Object||Array*/object, /*String*/property, /*anything*/value){
                //      summary:
                //              Set a property value to an object
                //      description:
                //              'value' is set to 'property' of 'object'.
                //              If 'property' ends with an array index, it is used to indentify
                //              an element of an array property to set the value.
                //              If 'object' implements setPropertyValue(), it is called with
                //              'property' and 'value' to set the property value.
                //              If 'object' implements a setter for the property, it is called
                //              with 'value' to set the property value.
                //      object:
                //              An object
                //      property:
                //              A property name
                //      value:
                //              A value to set
                var i1 = property.indexOf('[');
                if(i1 >= 0){
                        var i2 = property.indexOf(']');
                        var index = property.substring(i1 + 1, i2);
                        var array = null;
                        if(i1 === 0){ // object is array
                                array = object;
                        }else{
                                property = property.substring(0, i1);
                                array = this._getPropertyValue(object, property);
                                if(!array){
                                        array = [];
                                        this._setPropertyValue(object, property, array);
                                }
                        }
                        array[index] = value;
                }else if(object.setPropertyValue){
                        object.setPropertyValue(property, value);
                }else{
                        var setter = "set" + property.charAt(0).toUpperCase() + property.substring(1);
                        if(object[setter]){
                                object[setter](value);
                        }else{
                                object[property] = value;
                        }
                }
        }
});

}