home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Nave / sky-chopper.swf / scripts / __Packages / mx / data / binding / FieldAccessor.as < prev    next >
Encoding:
Text File  |  2005-09-29  |  16.1 KB  |  501 lines
  1. class mx.data.binding.FieldAccessor
  2. {
  3.    var component;
  4.    var property;
  5.    var parentObj;
  6.    var fieldName;
  7.    var m_location;
  8.    var type;
  9.    var index;
  10.    var xpath;
  11.    var data;
  12.    static var xmlNodeFactory = new XML();
  13.    function FieldAccessor(component, property, parentObj, fieldName, type, index, parentField)
  14.    {
  15.       this.component = component;
  16.       this.property = property;
  17.       this.parentObj = parentObj;
  18.       this.fieldName = fieldName;
  19.       if(component == parentObj)
  20.       {
  21.          this.m_location = undefined;
  22.       }
  23.       else if(parentField.m_location == undefined)
  24.       {
  25.          this.m_location = fieldName;
  26.       }
  27.       else
  28.       {
  29.          this.m_location = parentField.m_location + "." + fieldName;
  30.       }
  31.       this.type = type;
  32.       this.index = index;
  33.    }
  34.    function getValue()
  35.    {
  36.       var _loc2_ = this.getFieldData();
  37.       if(_loc2_ == null && this.type.value != undefined)
  38.       {
  39.          var _loc3_ = new mx.data.binding.TypedValue(this.type.value,"String");
  40.          _loc3_.getDefault = true;
  41.          this.component.getField(this.fieldName).setAnyTypedValue(_loc3_);
  42.          _loc2_ = _loc3_.value;
  43.       }
  44.       if(this.isXML(_loc2_) && _loc2_.childNodes.length == 1 && _loc2_.firstChild.nodeType == 3)
  45.       {
  46.          return _loc2_.firstChild.nodeValue;
  47.       }
  48.       return _loc2_;
  49.    }
  50.    function setValue(newValue, newTypedValue)
  51.    {
  52.       if(newTypedValue.getDefault)
  53.       {
  54.          newTypedValue.value = newValue;
  55.       }
  56.       else
  57.       {
  58.          if(this.xpath != null)
  59.          {
  60.             var _loc5_ = this.getFieldData();
  61.             if(_loc5_ != null)
  62.             {
  63.                mx.data.binding.FieldAccessor.setXMLData(_loc5_,newValue);
  64.             }
  65.             else
  66.             {
  67.                _global.__dataLogger.logData(this.component,"Can\'t assign to \'<property>:<xpath>\' because there is no element at the given path",this);
  68.             }
  69.          }
  70.          else if(this.isXML(this.parentObj))
  71.          {
  72.             if(this.type.category == "attribute")
  73.             {
  74.                this.parentObj.attributes[this.fieldName] = newValue;
  75.             }
  76.             else if(this.type.category != "array")
  77.             {
  78.                _loc5_ = this.getOrCreateFieldData();
  79.                mx.data.binding.FieldAccessor.setXMLData(_loc5_,newValue);
  80.             }
  81.          }
  82.          else
  83.          {
  84.             if(this.parentObj == null)
  85.             {
  86.                _global.__dataLogger.logData(this.component,"Can\'t set field \'<property>/<location>\' because the field doesn\'t exist",this);
  87.             }
  88.             this.parentObj[this.fieldName] = newValue;
  89.          }
  90.          this.component.propertyModified(this.property,this.xpath == null && this.parentObj == this.component,newTypedValue.type);
  91.       }
  92.    }
  93.    static function isActionScriptPath(str)
  94.    {
  95.       var _loc2_ = str.toLowerCase();
  96.       var _loc3_ = "0123456789abcdefghijklmnopqrstuvwxyz_.";
  97.       var _loc1_ = 0;
  98.       while(_loc1_ < _loc2_.length)
  99.       {
  100.          if(-1 == _loc3_.indexOf(_loc2_.charAt(_loc1_)))
  101.          {
  102.             return false;
  103.          }
  104.          _loc1_ = _loc1_ + 1;
  105.       }
  106.       return true;
  107.    }
  108.    static function createFieldAccessor(component, property, location, type, mustExist)
  109.    {
  110.       if(mustExist && component[property] == null)
  111.       {
  112.          _global.__dataLogger.logData(component,"Warning: property \'<property>\' does not exist",{property:property});
  113.          return null;
  114.       }
  115.       var _loc5_ = new mx.data.binding.FieldAccessor(component,property,component,property,type,null,null);
  116.       if(location == null)
  117.       {
  118.          return _loc5_;
  119.       }
  120.       var _loc7_ = null;
  121.       if(location.indices != null)
  122.       {
  123.          _loc7_ = location.indices;
  124.          location = location.path;
  125.       }
  126.       if(typeof location == "string")
  127.       {
  128.          if(_loc7_ != null)
  129.          {
  130.             _global.__dataLogger.logData(component,"Warning: ignoring index values for property \'<property>\', path \'<location>\'",{property:property,location:location});
  131.          }
  132.          if(!mx.data.binding.FieldAccessor.isActionScriptPath(String(location)))
  133.          {
  134.             _loc5_.xpath = location;
  135.             return _loc5_;
  136.          }
  137.          location = location.split(".");
  138.       }
  139.       if(location instanceof Array)
  140.       {
  141.          var _loc3_ = undefined;
  142.          var _loc11_ = 0;
  143.          _loc3_ = 0;
  144.          while(_loc3_ < location.length)
  145.          {
  146.             var _loc2_ = null;
  147.             var _loc4_ = location[_loc3_];
  148.             if(_loc4_ == "[n]")
  149.             {
  150.                if(_loc7_ == null)
  151.                {
  152.                   _global.__dataLogger.logData(component,"Error: indices for <property>:<location> are null, but [n] appears in the location.",{property:property,location:location});
  153.                   return null;
  154.                }
  155.                _loc2_ = _loc7_[_loc11_++];
  156.                if(_loc2_ == null)
  157.                {
  158.                   _global.__dataLogger.logData(component,"Error: not enough index values for <property>:<location>",{property:property,location:location});
  159.                   return null;
  160.                }
  161.             }
  162.             _loc5_ = _loc5_.getChild(_loc4_,_loc2_,mustExist);
  163.             _loc3_ = _loc3_ + 1;
  164.          }
  165.          if(mustExist && _loc5_.getValue() == null)
  166.          {
  167.             _global.__dataLogger.logData(component,"Warning: field <property>:<m_location> does not exist, or is null",_loc5_);
  168.          }
  169.          return _loc5_;
  170.       }
  171.       trace("unrecognized location: " + mx.data.binding.ObjectDumper.toString(location));
  172.       return null;
  173.    }
  174.    function getFieldAccessor()
  175.    {
  176.       return this;
  177.    }
  178.    function getChild(childName, index, mustExist)
  179.    {
  180.       if(childName == ".")
  181.       {
  182.          return this;
  183.       }
  184.       var _loc2_ = this.getOrCreateFieldData(mustExist);
  185.       if(_loc2_ == null)
  186.       {
  187.          return null;
  188.       }
  189.       var _loc4_ = mx.data.binding.FieldAccessor.findElementType(this.type,childName);
  190.       return new mx.data.binding.FieldAccessor(this.component,this.property,_loc2_,childName,_loc4_,index,this);
  191.    }
  192.    function getOrCreateFieldData(mustExist)
  193.    {
  194.       var _loc3_ = this.getFieldData();
  195.       if(_loc3_ == null)
  196.       {
  197.          if(mustExist)
  198.          {
  199.             _global.__dataLogger.logData(this.component,"Warning: field <property>:<m_location> does not exist",this);
  200.          }
  201.          else
  202.          {
  203.             this.setupComplexField();
  204.             _loc3_ = this.getFieldData();
  205.          }
  206.       }
  207.       return _loc3_;
  208.    }
  209.    function evaluateSubPath(obj, type)
  210.    {
  211.       var path = type.path;
  212.       if(mx.data.binding.FieldAccessor.isActionScriptPath(path))
  213.       {
  214.          var tokens = path.split(".");
  215.          var i = 0;
  216.          while(i < tokens.length)
  217.          {
  218.             var token = tokens[i];
  219.             if(this.isXML(obj))
  220.             {
  221.                obj = obj.firstChild;
  222.                while(obj != null)
  223.                {
  224.                   if(mx.data.binding.FieldAccessor.toLocalName(obj.nodeName) == token)
  225.                   {
  226.                      break;
  227.                   }
  228.                   obj = obj.nextSibling;
  229.                }
  230.             }
  231.             else
  232.             {
  233.                obj = obj[token];
  234.             }
  235.             if(obj == null)
  236.             {
  237.                _global.__dataLogger.logData(this.component,"Warning: path \'<path>\' evaluates to null, at \'<token>\' in <t.property>:<t.m_location>",{path:path,token:token,t:this});
  238.                break;
  239.             }
  240.             i++;
  241.          }
  242.       }
  243.       else if(this.isXML(obj))
  244.       {
  245.          if(path.charAt(0) != "/")
  246.          {
  247.             path = "/" + path;
  248.          }
  249.          path = mx.data.binding.FieldAccessor.toLocalName(obj.nodeName) + path;
  250.          var category = type.category == null ? (type.elements.length <= 0 ? "simple" : "complex") : type.category;
  251.          if(category == "simple" || category == "attribute")
  252.          {
  253.             obj = eval("obj" + mx.xpath.XPathAPI.getEvalString(obj,path));
  254.          }
  255.          else if(category == "complex")
  256.          {
  257.             obj = mx.xpath.XPathAPI.selectSingleNode(obj,path);
  258.          }
  259.          else if(category == "array")
  260.          {
  261.             obj = mx.xpath.XPathAPI.selectNodeList(obj,path);
  262.          }
  263.       }
  264.       else
  265.       {
  266.          _global.__dataLogger.logData(this.component,"Error: path \'<path>\' is an XPath. It cannot be applied to non-XML data <t.property>:<t.m_location>",{path:path,t:this});
  267.       }
  268.       return obj;
  269.    }
  270.    function getFieldData()
  271.    {
  272.       if(this.xpath != null)
  273.       {
  274.          var _loc4_ = this.parentObj[this.fieldName].firstChild;
  275.          while(_loc4_ != null && _loc4_.nodeType != 1)
  276.          {
  277.             _loc4_ = _loc4_.nextSibling;
  278.          }
  279.          var _loc8_ = mx.xpath.XPathAPI.selectSingleNode(_loc4_,this.xpath);
  280.          return _loc8_;
  281.       }
  282.       if(this.isXML(this.parentObj))
  283.       {
  284.          if(this.type.path != null)
  285.          {
  286.             return this.evaluateSubPath(this.parentObj,this.type);
  287.          }
  288.          if(this.type.category == "attribute")
  289.          {
  290.             return this.parentObj.attributes[this.fieldName];
  291.          }
  292.          var _loc3_ = this.parentObj.firstChild;
  293.          if(this.type.category == "array")
  294.          {
  295.             var _loc5_ = new Array();
  296.             while(_loc3_ != null)
  297.             {
  298.                if(mx.data.binding.FieldAccessor.toLocalName(_loc3_.nodeName) == this.fieldName)
  299.                {
  300.                   _loc5_.push(_loc3_);
  301.                }
  302.                _loc3_ = _loc3_.nextSibling;
  303.             }
  304.             return _loc5_;
  305.          }
  306.          while(_loc3_ != null)
  307.          {
  308.             if(mx.data.binding.FieldAccessor.toLocalName(_loc3_.nodeName) == this.fieldName)
  309.             {
  310.                return _loc3_;
  311.             }
  312.             _loc3_ = _loc3_.nextSibling;
  313.          }
  314.          return null;
  315.       }
  316.       if(this.fieldName == "[n]")
  317.       {
  318.          var _loc6_ = undefined;
  319.          if(this.index.component != null)
  320.          {
  321.             var _loc7_ = this.index.component.getField(this.index.property,this.index.location);
  322.             _loc6_ = _loc7_.getAnyTypedValue(["Number"]);
  323.             _loc6_ = _loc6_.value;
  324.          }
  325.          else
  326.          {
  327.             _loc6_ = this.index.constant;
  328.          }
  329.          var _loc9_ = Number(_loc6_);
  330.          if(typeof _loc6_ == "undefined")
  331.          {
  332.             _global.__dataLogger.logData(this.component,"Error: index specification \'<index>\' was not supplied, or incorrect, for <t.property>:<t.m_location>",{index:_loc9_,t:this});
  333.             return null;
  334.          }
  335.          if(_loc9_.toString() == "NaN")
  336.          {
  337.             _global.__dataLogger.logData(this.component,"Error: index value \'<index>\' for <t.property>:<t.m_location> is not a number",{index:_loc9_,t:this});
  338.             return null;
  339.          }
  340.          if(!(this.parentObj instanceof Array))
  341.          {
  342.             _global.__dataLogger.logData(this.component,"Error: indexed field <property>:<m_location> is not an array",this);
  343.             return null;
  344.          }
  345.          if(_loc9_ < 0 || _loc9_ >= this.parentObj.length)
  346.          {
  347.             _global.__dataLogger.logData(this.component,"Error: index \'<index>\' for <t.property>:<t.m_location> is out of bounds",{index:_loc9_,t:this});
  348.             return null;
  349.          }
  350.          _global.__dataLogger.logData(this.component,"Accessing item [<index>] of <t.property>:<t.m_location>",{index:_loc9_,t:this});
  351.          return this.parentObj[_loc9_];
  352.       }
  353.       if(this.type.path != null)
  354.       {
  355.          return this.evaluateSubPath(this.parentObj,this.type);
  356.       }
  357.       return this.parentObj[this.fieldName];
  358.    }
  359.    static function setXMLData(obj, newValue)
  360.    {
  361.       while(obj.hasChildNodes())
  362.       {
  363.          obj.firstChild.removeNode();
  364.       }
  365.       var _loc2_ = mx.data.binding.FieldAccessor.xmlNodeFactory.createTextNode(newValue);
  366.       obj.appendChild(_loc2_);
  367.    }
  368.    function setupComplexField()
  369.    {
  370.       var _loc2_ = undefined;
  371.       if(this.isXML(this.parentObj))
  372.       {
  373.          _loc2_ = mx.data.binding.FieldAccessor.xmlNodeFactory.createElement(this.fieldName);
  374.          this.parentObj.appendChild(_loc2_);
  375.       }
  376.       else if(this.dataIsXML())
  377.       {
  378.          this.parentObj[this.fieldName] = new XML();
  379.       }
  380.       else
  381.       {
  382.          this.parentObj[this.fieldName] = new Object();
  383.       }
  384.    }
  385.    static function findElementType(type, name)
  386.    {
  387.       var _loc1_ = 0;
  388.       while(_loc1_ < type.elements.length)
  389.       {
  390.          if(type.elements[_loc1_].name == name)
  391.          {
  392.             return type.elements[_loc1_].type;
  393.          }
  394.          _loc1_ = _loc1_ + 1;
  395.       }
  396.       return null;
  397.    }
  398.    function isXML(obj)
  399.    {
  400.       return obj instanceof XMLNode;
  401.    }
  402.    function dataIsXML()
  403.    {
  404.       return this.type.name == "XML";
  405.    }
  406.    static function accessField(component, fieldName, desiredTypes)
  407.    {
  408.       var _loc1_ = undefined;
  409.       _loc1_ = desiredTypes[fieldName];
  410.       if(_loc1_ == null)
  411.       {
  412.          _loc1_ = desiredTypes.dflt;
  413.       }
  414.       if(_loc1_ == null)
  415.       {
  416.          _loc1_ = desiredTypes;
  417.       }
  418.       var _loc4_ = component.createField("data",[fieldName]);
  419.       var _loc2_ = _loc4_.getAnyTypedValue([_loc1_]);
  420.       return _loc2_.value;
  421.    }
  422.    static function ExpandRecord(obj, objectType, desiredTypes)
  423.    {
  424.       var _loc4_ = new Object();
  425.       mx.data.binding.ComponentMixins.initComponent(_loc4_);
  426.       _loc4_.data = obj;
  427.       _loc4_.__schema = {elements:[{name:"data",type:objectType}]};
  428.       var _loc2_ = new Object();
  429.       if(objectType.elements.length > 0)
  430.       {
  431.          var _loc3_ = 0;
  432.          while(_loc3_ < objectType.elements.length)
  433.          {
  434.             var _loc10_ = objectType.elements[_loc3_].name;
  435.             _loc2_[_loc10_] = mx.data.binding.FieldAccessor.accessField(_loc4_,_loc10_,desiredTypes);
  436.             _loc3_ = _loc3_ + 1;
  437.          }
  438.       }
  439.       else if(obj instanceof XML || obj instanceof XMLNode)
  440.       {
  441.          if(obj.childNodes.length == 1 && obj.firstChild.nodeType == 3)
  442.          {
  443.             return obj.firstChild.nodeValue;
  444.          }
  445.          var _loc5_ = obj.lastChild;
  446.          while(_loc5_ != null)
  447.          {
  448.             _loc10_ = mx.data.binding.FieldAccessor.toLocalName(_loc5_.nodeName);
  449.             if(_loc10_ != null && _loc2_[_loc10_] == null)
  450.             {
  451.                _loc2_[_loc10_] = mx.data.binding.FieldAccessor.accessField(_loc4_,_loc10_,desiredTypes);
  452.             }
  453.             _loc5_ = _loc5_.previousSibling;
  454.          }
  455.          for(_loc10_ in obj.attributes)
  456.          {
  457.             if(_loc2_[_loc10_] != null)
  458.             {
  459.                _global.__dataLogger.logData(null,"Warning: attribute \'<name>\' has same name as an element, in XML object <obj>",{name:_loc10_,obj:obj});
  460.             }
  461.             _loc2_[_loc10_] = mx.data.binding.FieldAccessor.accessField(_loc4_,_loc10_,desiredTypes);
  462.          }
  463.       }
  464.       else
  465.       {
  466.          if(typeof obj != "object")
  467.          {
  468.             return obj;
  469.          }
  470.          for(_loc10_ in obj)
  471.          {
  472.             _loc2_[_loc10_] = mx.data.binding.FieldAccessor.accessField(_loc4_,_loc10_,desiredTypes);
  473.          }
  474.       }
  475.       return _loc2_;
  476.    }
  477.    static function wrapArray(theArray, itemType, desiredTypes)
  478.    {
  479.       var _loc4_ = {getItemAt:function(index)
  480.       {
  481.          var _loc2_ = this.data[index];
  482.          if(_loc2_ == undefined)
  483.          {
  484.             return undefined;
  485.          }
  486.          var _loc3_ = mx.data.binding.FieldAccessor.ExpandRecord(_loc2_,this.type,desiredTypes);
  487.          return _loc3_;
  488.       },getItemID:function(index)
  489.       {
  490.          return index;
  491.       },data:theArray,type:itemType,length:theArray.length};
  492.       return _loc4_;
  493.    }
  494.    static function toLocalName(nodeName)
  495.    {
  496.       var _loc1_ = nodeName.split(":");
  497.       var _loc2_ = _loc1_[_loc1_.length - 1];
  498.       return _loc2_;
  499.    }
  500. }
  501.