home *** CD-ROM | disk | FTP | other *** search
/ One Click 21 (Special) / OC021.iso / Interface / it.dig / scripts / __Packages / mx / xpath / XPathAPI.as < prev   
Encoding:
Text File  |  2006-07-04  |  13.5 KB  |  460 lines
  1. class mx.xpath.XPathAPI
  2. {
  3.    function XPathAPI()
  4.    {
  5.    }
  6.    static function getEvalString(node, path)
  7.    {
  8.       var _loc7_ = "";
  9.       var _loc4_ = null;
  10.       var _loc9_ = mx.xpath.XPathAPI.getPathSet(path);
  11.       var _loc3_ = _loc9_[0].nodeName;
  12.       var _loc8_ = undefined;
  13.       var _loc2_ = node;
  14.       var _loc5_ = false;
  15.       if(_loc3_ != undefined && (_loc3_ == "*" || node.nodeName == _loc3_))
  16.       {
  17.          var _loc6_ = 1;
  18.          while(_loc6_ < _loc9_.length)
  19.          {
  20.             _loc3_ = _loc9_[_loc6_].nodeName;
  21.             _loc8_ = _loc3_.indexOf("@");
  22.             if(_loc8_ >= 0)
  23.             {
  24.                _loc3_ = _loc3_.substring(_loc8_ + 1);
  25.                _loc5_ = _loc2_.attributes[_loc3_] != undefined;
  26.                _loc7_ += ".attributes." + _loc3_;
  27.             }
  28.             else
  29.             {
  30.                _loc5_ = false;
  31.                var _loc1_ = 0;
  32.                while(_loc1_ < _loc2_.childNodes.length)
  33.                {
  34.                   _loc4_ = _loc2_.childNodes[_loc1_];
  35.                   if(_loc4_.nodeName == _loc3_)
  36.                   {
  37.                      _loc7_ += ".childNodes." + _loc1_;
  38.                      _loc1_ = _loc2_.childNodes.length;
  39.                      _loc2_ = _loc4_;
  40.                      _loc5_ = true;
  41.                   }
  42.                   _loc1_ = _loc1_ + 1;
  43.                }
  44.             }
  45.             if(!_loc5_)
  46.             {
  47.                return "";
  48.             }
  49.             _loc6_ = _loc6_ + 1;
  50.          }
  51.          if(!_loc5_)
  52.          {
  53.             _loc7_ = "";
  54.          }
  55.          else if(_loc8_ == -1)
  56.          {
  57.             _loc7_ += ".firstChild.nodeValue";
  58.          }
  59.       }
  60.       else
  61.       {
  62.          _loc7_ = "";
  63.       }
  64.       return _loc7_;
  65.    }
  66.    static function selectNodeList(node, path)
  67.    {
  68.       var _loc2_ = new Array(node);
  69.       var _loc5_ = mx.xpath.XPathAPI.getPathSet(path);
  70.       var _loc4_ = _loc5_[0];
  71.       var _loc6_ = _loc4_.nodeName;
  72.       var _loc1_ = null;
  73.       if(_loc6_ != undefined && (_loc6_ == "*" || node.nodeName == _loc6_))
  74.       {
  75.          if(_loc4_.filter.length > 0)
  76.          {
  77.             _loc1_ = new mx.xpath.FilterStack(_loc4_.filter);
  78.             _loc2_ = mx.xpath.XPathAPI.filterNodes(_loc2_,_loc1_);
  79.          }
  80.          if(_loc2_.length > 0)
  81.          {
  82.             var _loc3_ = 1;
  83.             while(_loc3_ < _loc5_.length)
  84.             {
  85.                _loc4_ = _loc5_[_loc3_];
  86.                _loc2_ = mx.xpath.XPathAPI.getAllChildNodesByName(_loc2_,_loc4_.nodeName);
  87.                if(_loc4_.filter.length > 0)
  88.                {
  89.                   _loc1_ = new mx.xpath.FilterStack(_loc4_.filter);
  90.                }
  91.                else
  92.                {
  93.                   _loc1_ = null;
  94.                }
  95.                if(_loc1_ != null && _loc1_.exprs.length > 0)
  96.                {
  97.                   _loc2_ = mx.xpath.XPathAPI.filterNodes(_loc2_,_loc1_);
  98.                }
  99.                _loc3_ = _loc3_ + 1;
  100.             }
  101.          }
  102.       }
  103.       else
  104.       {
  105.          _loc2_ = new Array();
  106.       }
  107.       return _loc2_;
  108.    }
  109.    static function selectSingleNode(node, path)
  110.    {
  111.       var _loc1_ = mx.xpath.XPathAPI.selectNodeList(node,path);
  112.       if(_loc1_.length > 0)
  113.       {
  114.          return _loc1_[0];
  115.       }
  116.       return null;
  117.    }
  118.    static function setNodeValue(node, path, newValue)
  119.    {
  120.       var _loc1_ = new Array(node);
  121.       var _loc9_ = mx.xpath.XPathAPI.getPathSet(path);
  122.       var _loc7_ = _loc9_[_loc9_.length - 1].nodeName;
  123.       if(_loc7_.charAt(0) == "@")
  124.       {
  125.          _loc7_ = _loc7_.substring(1,_loc7_.length);
  126.          _loc9_.pop();
  127.       }
  128.       else
  129.       {
  130.          _loc7_ = null;
  131.       }
  132.       var _loc5_ = _loc9_[0];
  133.       var _loc11_ = _loc5_.nodeName;
  134.       var _loc3_ = null;
  135.       if(_loc11_ != undefined && (_loc11_ == "*" || node.nodeName == _loc11_))
  136.       {
  137.          if(_loc5_.filter.length > 0)
  138.          {
  139.             _loc3_ = new mx.xpath.FilterStack(_loc5_.filter);
  140.             _loc1_ = mx.xpath.XPathAPI.filterNodes(_loc1_,_loc3_);
  141.          }
  142.          if(_loc1_.length > 0)
  143.          {
  144.             var _loc2_ = 1;
  145.             while(_loc2_ < _loc9_.length)
  146.             {
  147.                _loc5_ = _loc9_[_loc2_];
  148.                _loc1_ = mx.xpath.XPathAPI.getAllChildNodesByName(_loc1_,_loc5_.nodeName);
  149.                if(_loc5_.filter.length > 0)
  150.                {
  151.                   _loc3_ = new mx.xpath.FilterStack(_loc5_.filter);
  152.                }
  153.                else
  154.                {
  155.                   _loc3_ = null;
  156.                }
  157.                if(_loc3_ != null && _loc3_.exprs.length > 0)
  158.                {
  159.                   _loc1_ = mx.xpath.XPathAPI.filterNodes(_loc1_,_loc3_);
  160.                }
  161.                _loc2_ = _loc2_ + 1;
  162.             }
  163.          }
  164.       }
  165.       else
  166.       {
  167.          _loc1_ = new Array();
  168.       }
  169.       var _loc4_ = null;
  170.       var _loc6_ = null;
  171.       var _loc10_ = new XML();
  172.       _loc2_ = 0;
  173.       while(_loc2_ < _loc1_.length)
  174.       {
  175.          if(_loc7_ != null)
  176.          {
  177.             _loc1_[_loc2_].attributes[_loc7_] = newValue;
  178.          }
  179.          else
  180.          {
  181.             _loc4_ = _loc1_[_loc2_];
  182.             if(_loc4_.firstChild == null || _loc4_.firstChild.nodeType != 3)
  183.             {
  184.                _loc6_ = _loc10_.createTextNode(newValue);
  185.                _loc4_.appendChild(_loc6_);
  186.             }
  187.             else
  188.             {
  189.                _loc6_ = _loc4_.firstChild;
  190.                _loc6_.nodeValue = newValue;
  191.             }
  192.          }
  193.          _loc2_ = _loc2_ + 1;
  194.       }
  195.       return _loc1_.length;
  196.    }
  197.    static function copyStack(toStk, fromStk)
  198.    {
  199.       var _loc1_ = 0;
  200.       while(_loc1_ < fromStk.length)
  201.       {
  202.          toStk.splice(_loc1_,0,fromStk[_loc1_]);
  203.          _loc1_ = _loc1_ + 1;
  204.       }
  205.    }
  206.    static function evalExpr(expr, node)
  207.    {
  208.       var _loc2_ = true;
  209.       if(expr.attr)
  210.       {
  211.          _loc2_ = expr.value == null ? node.attributes[expr.name] != null : node.attributes[expr.name] == expr.value;
  212.       }
  213.       else
  214.       {
  215.          var _loc3_ = mx.xpath.XPathAPI.getChildNodeByName(node,expr.name);
  216.          if(_loc3_ != null)
  217.          {
  218.             _loc2_ = expr.value == null ? true : _loc3_.firstChild.nodeValue == expr.value;
  219.          }
  220.          else
  221.          {
  222.             _loc2_ = false;
  223.          }
  224.       }
  225.       return _loc2_;
  226.    }
  227.    static function filterNodes(nodeList, stack)
  228.    {
  229.       var _loc13_ = new Array();
  230.       var _loc2_ = undefined;
  231.       var _loc3_ = undefined;
  232.       var _loc9_ = undefined;
  233.       var _loc6_ = undefined;
  234.       var _loc10_ = undefined;
  235.       var _loc1_ = true;
  236.       var _loc4_ = undefined;
  237.       var _loc5_ = undefined;
  238.       var _loc8_ = 0;
  239.       while(_loc8_ < nodeList.length)
  240.       {
  241.          _loc5_ = true;
  242.          _loc2_ = new Array();
  243.          _loc3_ = new Array();
  244.          mx.xpath.XPathAPI.copyStack(_loc2_,stack.exprs);
  245.          mx.xpath.XPathAPI.copyStack(_loc3_,stack.ops);
  246.          _loc4_ = nodeList[_loc8_];
  247.          while(_loc2_.length > 0 && _loc5_)
  248.          {
  249.             if(typeof _loc2_[_loc2_.length - 1] == "object")
  250.             {
  251.                _loc9_ = _loc2_.pop();
  252.                _loc1_ = mx.xpath.XPathAPI.evalExpr(_loc9_,_loc4_);
  253.             }
  254.             else
  255.             {
  256.                _loc10_ = Boolean(_loc2_.pop());
  257.                _loc1_ = _loc10_;
  258.             }
  259.             if(_loc3_.length > 0)
  260.             {
  261.                var _loc7_ = _loc2_.pop();
  262.                _loc6_ = _loc7_;
  263.                switch(_loc3_[_loc3_.length - 1])
  264.                {
  265.                   case "and":
  266.                      _loc1_ = _loc1_ && mx.xpath.XPathAPI.evalExpr(_loc6_,_loc4_);
  267.                      _loc5_ = _loc1_;
  268.                      break;
  269.                   case "or":
  270.                      _loc1_ = _loc1_ || mx.xpath.XPathAPI.evalExpr(_loc6_,_loc4_);
  271.                      _loc5_ = !_loc1_;
  272.                }
  273.                _loc3_.pop();
  274.                _loc2_.push(_loc1_);
  275.             }
  276.          }
  277.          if(_loc1_)
  278.          {
  279.             _loc13_.push(_loc4_);
  280.          }
  281.          _loc8_ = _loc8_ + 1;
  282.       }
  283.       return _loc13_;
  284.    }
  285.    static function getAllChildNodesByName(nodeList, name)
  286.    {
  287.       var _loc5_ = new Array();
  288.       var _loc2_ = undefined;
  289.       var _loc3_ = 0;
  290.       while(_loc3_ < nodeList.length)
  291.       {
  292.          _loc2_ = nodeList[_loc3_].childNodes;
  293.          if(_loc2_ != null)
  294.          {
  295.             var _loc1_ = 0;
  296.             while(_loc1_ < _loc2_.length)
  297.             {
  298.                if(name == "*" || _loc2_[_loc1_].nodeName == name)
  299.                {
  300.                   _loc5_.push(_loc2_[_loc1_]);
  301.                }
  302.                _loc1_ = _loc1_ + 1;
  303.             }
  304.          }
  305.          _loc3_ = _loc3_ + 1;
  306.       }
  307.       return _loc5_;
  308.    }
  309.    static function getChildNodeByName(node, nodeName)
  310.    {
  311.       var _loc2_ = undefined;
  312.       var _loc3_ = node.childNodes;
  313.       var _loc1_ = 0;
  314.       while(_loc1_ < _loc3_.length)
  315.       {
  316.          _loc2_ = _loc3_[_loc1_];
  317.          if(_loc2_.nodeName == nodeName)
  318.          {
  319.             return _loc2_;
  320.          }
  321.          _loc1_ = _loc1_ + 1;
  322.       }
  323.       return null;
  324.    }
  325.    static function getKeyValues(node, keySpec)
  326.    {
  327.       var _loc5_ = "";
  328.       var _loc3_ = new mx.utils.StringTokenParser(keySpec);
  329.       var _loc2_ = _loc3_.nextToken();
  330.       var _loc1_ = undefined;
  331.       var _loc6_ = undefined;
  332.       while(_loc2_ != mx.utils.StringTokenParser.tkEOF)
  333.       {
  334.          _loc1_ = _loc3_.token;
  335.          _loc5_ += " " + _loc1_;
  336.          if(_loc2_ == mx.utils.StringTokenParser.tkSymbol)
  337.          {
  338.             if(_loc1_ == "@")
  339.             {
  340.                _loc2_ = _loc3_.nextToken();
  341.                _loc1_ = _loc3_.token;
  342.                if(_loc2_ == mx.utils.StringTokenParser.tkSymbol)
  343.                {
  344.                   _loc5_ += _loc1_ + "=\'" + node.attributes[_loc1_] + "\'";
  345.                }
  346.             }
  347.             else if(_loc1_ == "/")
  348.             {
  349.                _loc2_ = _loc3_.nextToken();
  350.                if(_loc2_ == mx.utils.StringTokenParser.tkSymbol)
  351.                {
  352.                   _loc1_ = _loc3_.token;
  353.                   node = mx.xpath.XPathAPI.getChildNodeByName(node,_loc1_);
  354.                   if(node != null)
  355.                   {
  356.                      _loc5_ += _loc1_;
  357.                   }
  358.                }
  359.             }
  360.             else if(_loc1_ != "and" && _loc1_ != "or" && _loc1_ != "[" && _loc1_ != "]")
  361.             {
  362.                _loc6_ = mx.xpath.XPathAPI.getChildNodeByName(node,_loc1_);
  363.                if(_loc6_ != null)
  364.                {
  365.                   _loc5_ += "=\'" + _loc6_.firstChild.nodeValue + "\'";
  366.                }
  367.             }
  368.          }
  369.          if(node == null)
  370.          {
  371.             trace("Invalid keySpec specified. \'" + keySpec + "\' Error.");
  372.             return "ERR";
  373.          }
  374.          _loc2_ = _loc3_.nextToken();
  375.       }
  376.       return _loc5_.slice(1);
  377.    }
  378.    static function getPath(node, keySpecs)
  379.    {
  380.       var _loc2_ = "";
  381.       var _loc5_ = keySpecs[node.nodeName];
  382.       if(_loc5_ == undefined)
  383.       {
  384.          var _loc8_ = "";
  385.          var _loc10_ = undefined;
  386.          for(_loc10_ in node.attributes)
  387.          {
  388.             _loc8_ += "@" + _loc10_ + "=\'" + node.attributes[_loc10_] + "\' and ";
  389.          }
  390.          var _loc7_ = "";
  391.          var _loc1_ = undefined;
  392.          var _loc6_ = undefined;
  393.          var _loc4_ = 0;
  394.          while(_loc4_ < node.childNodes.length)
  395.          {
  396.             _loc1_ = node.childNodes[_loc4_];
  397.             _loc6_ = _loc1_.firstChild.nodeValue;
  398.             if(_loc6_ != undefined)
  399.             {
  400.                _loc7_ += _loc1_.nodeName + "=\'" + _loc6_ + "\' and ";
  401.             }
  402.             _loc4_ = _loc4_ + 1;
  403.          }
  404.          if(_loc8_.length > 0)
  405.          {
  406.             if(_loc7_.length > 0)
  407.             {
  408.                _loc2_ = "/" + node.nodeName + "[" + _loc8_ + _loc7_.substring(0,_loc7_.length - 4) + "]";
  409.             }
  410.             else
  411.             {
  412.                _loc2_ = "/" + node.nodeName + "[" + _loc8_.substring(0,_loc8_.length - 4) + "]";
  413.             }
  414.          }
  415.          else
  416.          {
  417.             _loc2_ = "/" + node.nodeName + "[" + _loc7_.substring(0,_loc7_.length - 4) + "]";
  418.          }
  419.       }
  420.       else
  421.       {
  422.          _loc2_ += "/" + node.nodeName + mx.xpath.XPathAPI.getKeyValues(node,_loc5_);
  423.       }
  424.       _loc1_ = node.parentNode;
  425.       while(_loc1_.parentNode != null)
  426.       {
  427.          _loc5_ = keySpecs[_loc1_.nodeName];
  428.          if(_loc5_ != undefined)
  429.          {
  430.             _loc2_ = "/" + _loc1_.nodeName + mx.xpath.XPathAPI.getKeyValues(_loc1_,_loc5_) + _loc2_;
  431.          }
  432.          else
  433.          {
  434.             _loc2_ = "/" + _loc1_.nodeName + _loc2_;
  435.          }
  436.          _loc1_ = _loc1_.parentNode;
  437.       }
  438.       return _loc2_;
  439.    }
  440.    static function getPathSet(path)
  441.    {
  442.       var _loc6_ = new Array();
  443.       var _loc4_ = undefined;
  444.       var _loc1_ = undefined;
  445.       var _loc2_ = undefined;
  446.       var _loc5_ = undefined;
  447.       while(path.length > 0)
  448.       {
  449.          _loc4_ = path.lastIndexOf("/");
  450.          _loc1_ = path.substring(_loc4_ + 1);
  451.          _loc2_ = _loc1_.indexOf("[",0);
  452.          _loc5_ = _loc2_ < 0 ? "" : _loc1_.substring(_loc2_ + 1,_loc1_.length - 1);
  453.          _loc1_ = _loc2_ < 0 ? _loc1_ : _loc1_.substring(0,_loc2_);
  454.          _loc6_.splice(0,0,new mx.xpath.NodePathInfo(_loc1_,_loc5_));
  455.          path = path.substring(0,_loc4_);
  456.       }
  457.       return _loc6_;
  458.    }
  459. }
  460.