home *** CD-ROM | disk | FTP | other *** search
/ ftp.novell.com / 2014.06.ftp.novell.com.tar / ftp.novell.com / forge / camtasia.msi / Cabs.w1.cab / camtasia_player_ext.swf9 / scripts / __Packages / mx / controls / Tree.as < prev    next >
Text File  |  2009-08-17  |  20KB  |  643 lines
  1. class mx.controls.Tree extends mx.controls.List
  2. {
  3.    static var symbolName = "Tree";
  4.    static var symbolOwner = mx.controls.Tree;
  5.    var className = "Tree";
  6.    static var version = "2.0.2.126";
  7.    static var mixIt2 = mx.controls.treeclasses.TreeDataProvider.Initialize(XMLNode);
  8.    var isNewRowStyle = {depthColors:true,indentation:true,disclosureOpenIcon:true,disclosureClosedIcon:true,folderOpenIcon:true,folderClosedIcon:true,defaultLeafIcon:true};
  9.    var __rowRenderer = "TreeRow";
  10.    var isOpening = false;
  11.    var minScrollInterval = 50;
  12.    function Tree()
  13.    {
  14.       super();
  15.    }
  16.    function setIcon(node, iconID, iconID2)
  17.    {
  18.       if(this.nodeIcons == undefined)
  19.       {
  20.          this.nodeIcons = new Object();
  21.       }
  22.       if(iconID2 == undefined)
  23.       {
  24.          iconID2 = iconID;
  25.       }
  26.       var _loc0_ = null;
  27.       var _loc3_ = this.nodeIcons[node.getID()] = {iconID:iconID,iconID2:iconID2};
  28.       this.invUpdateControl = true;
  29.       this.invalidate();
  30.    }
  31.    function getIsBranch(node)
  32.    {
  33.       return node.hasChildNodes() || this.branchNodes[node.getID()] != undefined;
  34.    }
  35.    function setIsBranch(node, branch)
  36.    {
  37.       if(this.branchNodes == undefined)
  38.       {
  39.          this.branchNodes = new Object();
  40.       }
  41.       if(!branch)
  42.       {
  43.          delete this.branchNodes[node.getID()];
  44.       }
  45.       else
  46.       {
  47.          this.branchNodes[node.getID()] = true;
  48.       }
  49.       if(this.isNodeVisible(node))
  50.       {
  51.          this.invUpdateControl = true;
  52.          this.invalidate();
  53.       }
  54.    }
  55.    function getNodeDepth(node)
  56.    {
  57.       var _loc3_ = 0;
  58.       var _loc2_ = node;
  59.       while(_loc2_.parentNode != undefined && _loc2_ != this.treeDataProvider)
  60.       {
  61.          _loc3_ = _loc3_ + 1;
  62.          _loc2_ = _loc2_.parentNode;
  63.       }
  64.       return _loc3_;
  65.    }
  66.    function getIsOpen(node)
  67.    {
  68.       return this.openNodes[node.getID()] == true;
  69.    }
  70.    function setIsOpen(node, open, animate, fireEvent)
  71.    {
  72.       if(!this.getIsBranch(node) || this.getIsOpen(node) == open || this.isOpening)
  73.       {
  74.          return undefined;
  75.       }
  76.       if(open)
  77.       {
  78.          this.openNodes[node.getID()] = open;
  79.       }
  80.       if(this.isNodeVisible(node))
  81.       {
  82.          this.nodeList = this.getDisplayList(node,!open);
  83.          this.rowIndex = this.getDisplayIndex(node) + 1 - this.__vPosition;
  84.          var _loc6_ = Math.min(this.nodeList.length,this.__rowCount - this.rowIndex);
  85.          var _loc13_ = this.getStyle("openDuration");
  86.          if(animate && this.rowIndex < this.__rowCount && _loc6_ > 0 && _loc6_ < 20 && _loc13_ != 0)
  87.          {
  88.             this.tween.endTween();
  89.             this.opening = open;
  90.             this.isOpening = true;
  91.             var _loc7_ = _loc6_ * this.__rowHeight;
  92.             var _loc15_ = this.rowIndex;
  93.             while(_loc15_ < this.__rowCount)
  94.             {
  95.                this.rows[_loc15_].__lastY = this.rows[_loc15_]._y;
  96.                _loc15_ = _loc15_ + 1;
  97.             }
  98.             this.maskList = new Array();
  99.             this.rowList = new Array();
  100.             var _loc4_ = this.__viewMetrics;
  101.             var _loc12_ = !(this.__hScrollPolicy == "on" || this.__hScrollPolicy == "auto") ? this.__width - _loc4_.left - _loc4_.right : this.__width + this.__maxHPosition;
  102.             _loc15_ = 0;
  103.             while(_loc15_ < _loc6_)
  104.             {
  105.                var _loc0_ = null;
  106.                var _loc3_ = this.maskList[_loc15_] = this.attachMovie("BoundingBox","openMask" + _loc15_,2001 + _loc15_);
  107.                _loc3_._width = this.__width - _loc4_.left - _loc4_.right;
  108.                _loc3_._x = _loc4_.left;
  109.                _loc3_._height = _loc7_;
  110.                _loc3_._y = this.rows[this.rowIndex]._y;
  111.                var _loc0_ = null;
  112.                var _loc2_ = this.rowList[_loc15_] = this.listContent.createObject(this.__rowRenderer,"treeRow" + this.topRowZ++,this.topRowZ,{owner:this,styleName:this});
  113.                _loc2_._x = _loc4_.left;
  114.                _loc2_.setSize(_loc12_,this.__rowHeight);
  115.                if(open)
  116.                {
  117.                   _loc2_.drawRow(this.nodeList[_loc15_],"normal");
  118.                   _loc2_._y = this.rows[this.rowIndex]._y - _loc7_ + this.__rowHeight * _loc15_;
  119.                   _loc2_.setMask(_loc3_);
  120.                }
  121.                else
  122.                {
  123.                   var _loc5_ = Math.max(this.__vPosition + this.__rowCount + _loc15_ + this.nodeList.length - _loc6_,this.rowIndex + this.nodeList.length);
  124.                   _loc2_.drawRow(this.__dataProvider.getItemAt(_loc5_),this.getStateAt(_loc5_));
  125.                   _loc2_._y = this.rows[this.__rowCount - 1]._y + (_loc15_ + 1) * this.__rowHeight;
  126.                   this.rows[this.rowIndex + _loc15_].setMask(_loc3_);
  127.                }
  128.                _loc2_.__lastY = _loc2_._y;
  129.                _loc15_ = _loc15_ + 1;
  130.             }
  131.             _loc13_ *= Math.max(_loc6_ / 5,1);
  132.             if(fireEvent)
  133.             {
  134.                this.eventAfterTween = node;
  135.             }
  136.             this.tween = new mx.effects.Tween(this,0,!open ? -1 * _loc7_ : _loc7_,_loc13_,5);
  137.             var _loc16_ = this.getStyle("openEasing");
  138.             if(_loc16_ != undefined)
  139.             {
  140.                this.tween.easingEquation = _loc16_;
  141.             }
  142.          }
  143.          else
  144.          {
  145.             this.isOpening = false;
  146.             if(open)
  147.             {
  148.                this.addItemsAt(this.getDisplayIndex(node) + 1,this.nodeList);
  149.             }
  150.             else
  151.             {
  152.                this.__dataProvider.removeItemsAt(this.getDisplayIndex(node) + 1,this.nodeList.length);
  153.             }
  154.             this.invScrollProps = true;
  155.             if(fireEvent)
  156.             {
  157.                this.eventPending = node;
  158.             }
  159.             this.invalidate();
  160.          }
  161.       }
  162.       if(!open)
  163.       {
  164.          this.openNodes[node.getID()] = open;
  165.       }
  166.       _loc15_ = this.getDisplayIndex(node);
  167.       var _loc14_ = this.rows[_loc15_ - this.__vPosition];
  168.       _loc14_.drawRow(_loc14_.item,this.getStateAt(_loc15_));
  169.    }
  170.    function onTweenUpdate(val)
  171.    {
  172.       var _loc2_ = this.rowIndex;
  173.       while(_loc2_ < this.__rowCount)
  174.       {
  175.          this.rows[_loc2_]._y = this.rows[_loc2_].__lastY + val;
  176.          _loc2_ = _loc2_ + 1;
  177.       }
  178.       _loc2_ = 0;
  179.       while(_loc2_ < this.rowList.length)
  180.       {
  181.          this.rowList[_loc2_]._y = this.rowList[_loc2_].__lastY + val;
  182.          _loc2_ = _loc2_ + 1;
  183.       }
  184.    }
  185.    function onTweenEnd(val)
  186.    {
  187.       var _loc2_ = this.rowIndex;
  188.       while(_loc2_ < this.__rowCount)
  189.       {
  190.          this.rows[_loc2_]._y = this.rows[_loc2_].__lastY + val;
  191.          delete this.rows[_loc2_].__lastY;
  192.          if(_loc2_ >= this.__rowCount - this.rowList.length && this.opening)
  193.          {
  194.             this.rows[_loc2_].removeMovieClip();
  195.          }
  196.          _loc2_ = _loc2_ + 1;
  197.       }
  198.       _loc2_ = 0;
  199.       while(_loc2_ < this.rowList.length)
  200.       {
  201.          this.rowList[_loc2_]._y = this.rowList[_loc2_].__lastY + val;
  202.          if(this.opening)
  203.          {
  204.             this.rowList[_loc2_].setMask(undefined);
  205.          }
  206.          else
  207.          {
  208.             this.rows[this.rowIndex + _loc2_].removeMovieClip();
  209.          }
  210.          this.maskList[_loc2_].removeMovieClip();
  211.          _loc2_ = _loc2_ + 1;
  212.       }
  213.       this.isOpening = false;
  214.       this.vScroller.__set__scrollPosition(this.__vPosition);
  215.       if(this.opening)
  216.       {
  217.          var _loc4_ = this.rowIndex + this.rowList.length;
  218.          _loc2_ = this.__rowCount - 1;
  219.          while(_loc2_ >= _loc4_)
  220.          {
  221.             this.rows[_loc2_] = this.rows[_loc2_ - this.rowList.length];
  222.             this.rows[_loc2_].rowIndex = _loc2_;
  223.             _loc2_ = _loc2_ - 1;
  224.          }
  225.          _loc2_ = this.rowIndex;
  226.          while(_loc2_ < _loc4_)
  227.          {
  228.             this.rows[_loc2_] = this.rowList[_loc2_ - this.rowIndex];
  229.             this.rows[_loc2_].rowIndex = _loc2_;
  230.             _loc2_ = _loc2_ + 1;
  231.          }
  232.          this.addItemsAt(this.rowIndex + this.__vPosition,this.nodeList);
  233.       }
  234.       else
  235.       {
  236.          var _loc3_ = this.__rowCount - this.rowList.length;
  237.          _loc2_ = this.rowIndex;
  238.          while(_loc2_ < _loc3_)
  239.          {
  240.             this.rows[_loc2_] = this.rows[_loc2_ + this.rowList.length];
  241.             this.rows[_loc2_].rowIndex = _loc2_;
  242.             _loc2_ = _loc2_ + 1;
  243.          }
  244.          _loc2_ = _loc3_;
  245.          while(_loc2_ < this.__rowCount)
  246.          {
  247.             this.rows[_loc2_] = this.rowList[_loc2_ - _loc3_];
  248.             this.rows[_loc2_].rowIndex = _loc2_;
  249.             _loc2_ = _loc2_ + 1;
  250.          }
  251.          this.__dataProvider.removeItemsAt(this.rowIndex + this.__vPosition,this.nodeList.length);
  252.       }
  253.       if(this.eventAfterTween != undefined)
  254.       {
  255.          this.eventPending = this.eventAfterTween;
  256.          this.invalidate();
  257.          delete this.eventAfterTween;
  258.       }
  259.       delete this.tween;
  260.       delete this.invUpdateControl;
  261.    }
  262.    function size(Void)
  263.    {
  264.       this.tween.endTween();
  265.       super.size();
  266.    }
  267.    function setVPosition(pos)
  268.    {
  269.       if(this.isOpening)
  270.       {
  271.          return undefined;
  272.       }
  273.       super.setVPosition(pos);
  274.    }
  275.    function onScroll(evt)
  276.    {
  277.       if(this.isOpening)
  278.       {
  279.          return undefined;
  280.       }
  281.       super.onScroll(evt);
  282.    }
  283.    function addItemsAt(index, arr)
  284.    {
  285.       var _loc4_ = this.__dataProvider.slice(0,index);
  286.       var _loc3_ = this.__dataProvider.slice(index);
  287.       this.__dataProvider = _loc4_.concat(arr,_loc3_);
  288.       this.__dataProvider.addEventListener("modelChanged",this);
  289.       this.modelChanged({eventName:"addItems",firstItem:index,lastItem:index + arr.length - 1});
  290.    }
  291.    function setDataProvider(dP)
  292.    {
  293.       if(this.treeDataProvider != undefined)
  294.       {
  295.          this.treeDataProvider.removeEventListener(this);
  296.       }
  297.       if(typeof dP == "string")
  298.       {
  299.          dP = new XML(dP);
  300.       }
  301.       this.treeDataProvider = dP;
  302.       this.treeDataProvider.isTreeRoot = true;
  303.       this.setIsBranch(this.treeDataProvider,true);
  304.       this.setIsOpen(this.treeDataProvider,true);
  305.       this.setDisplayIndex(this.treeDataProvider,-1);
  306.       this.treeDataProvider.addEventListener("modelChanged",this);
  307.       this.modelChanged({eventName:"updateTree"});
  308.    }
  309.    function getDataProvider()
  310.    {
  311.       return this.treeDataProvider;
  312.    }
  313.    function refresh()
  314.    {
  315.       this.updateControl();
  316.    }
  317.    function addTreeNode(label, data)
  318.    {
  319.       if(this.treeDataProvider == undefined)
  320.       {
  321.          this.setDataProvider(new XML());
  322.       }
  323.       return this.treeDataProvider.addTreeNode(label,data);
  324.    }
  325.    function addTreeNodeAt(index, label, data)
  326.    {
  327.       if(this.treeDataProvider == undefined)
  328.       {
  329.          this.setDataProvider(new XML());
  330.       }
  331.       return this.treeDataProvider.addTreeNodeAt(index,label,data);
  332.    }
  333.    function getTreeNodeAt(index)
  334.    {
  335.       return this.treeDataProvider.getTreeNodeAt(index);
  336.    }
  337.    function removeTreeNodeAt(index)
  338.    {
  339.       return this.treeDataProvider.removeTreeNodeAt(index);
  340.    }
  341.    function removeAll()
  342.    {
  343.       return this.treeDataProvider.removeAll();
  344.    }
  345.    function getNodeDisplayedAt(index)
  346.    {
  347.       return this.__dataProvider.getItemAt(index);
  348.    }
  349.    function modelChanged(eventObj)
  350.    {
  351.       var _loc6_ = eventObj.eventName;
  352.       if(_loc6_ == "updateTree")
  353.       {
  354.          this.__dataProvider = this.getDisplayList(this.treeDataProvider);
  355.          this.__dataProvider.addEventListener("modelChanged",this);
  356.          super.modelChanged({eventName:"updateAll"});
  357.       }
  358.       else if(_loc6_ == "addNode")
  359.       {
  360.          var _loc8_ = eventObj.node;
  361.          if(this.isNodeVisible(_loc8_))
  362.          {
  363.             if(_loc8_.nextSibling != undefined)
  364.             {
  365.                this.setDisplayIndex(_loc8_,this.getDisplayIndex(_loc8_.nextSibling));
  366.             }
  367.             else if(_loc8_.previousSibling != undefined)
  368.             {
  369.                var _loc7_ = this.getDisplayList(_loc8_.previousSibling);
  370.                if(_loc7_.length > 0)
  371.                {
  372.                   this.setDisplayIndex(_loc8_,this.getDisplayIndex(_loc7_.pop()) + 1);
  373.                }
  374.                else
  375.                {
  376.                   this.setDisplayIndex(_loc8_,this.getDisplayIndex(_loc8_.previousSibling) + 1);
  377.                }
  378.             }
  379.             else
  380.             {
  381.                this.setDisplayIndex(_loc8_,this.getDisplayIndex(_loc8_.parentNode) + 1);
  382.             }
  383.             var _loc10_ = this.getDisplayList(_loc8_);
  384.             _loc10_.unshift(_loc8_);
  385.             this.addItemsAt(this.getDisplayIndex(_loc8_),_loc10_);
  386.          }
  387.          else
  388.          {
  389.             this.invUpdateControl = true;
  390.             this.invalidate();
  391.          }
  392.       }
  393.       else if(_loc6_ == "removeNode")
  394.       {
  395.          _loc8_ = eventObj.node;
  396.          var _loc9_ = this.getDisplayIndex(_loc8_);
  397.          if(_loc9_ != undefined)
  398.          {
  399.             var _loc11_ = this.getDisplayList(_loc8_);
  400.             this.__dataProvider.removeItemsAt(_loc9_,_loc11_.length + 1);
  401.          }
  402.       }
  403.       else if(_loc6_ == "addItems")
  404.       {
  405.          super.modelChanged(eventObj);
  406.          var _loc5_ = this.__dataProvider;
  407.          var _loc3_ = eventObj.firstItem;
  408.          while(_loc3_ < _loc5_.length)
  409.          {
  410.             this.setDisplayIndex(_loc5_[_loc3_],_loc3_);
  411.             _loc3_ = _loc3_ + 1;
  412.          }
  413.       }
  414.       else if(_loc6_ == "removeItems")
  415.       {
  416.          _loc5_ = this.__dataProvider;
  417.          _loc3_ = eventObj.firstItem;
  418.          while(_loc3_ < _loc5_.length)
  419.          {
  420.             this.setDisplayIndex(_loc5_[_loc3_],_loc3_);
  421.             _loc3_ = _loc3_ + 1;
  422.          }
  423.          super.modelChanged(eventObj);
  424.       }
  425.       else
  426.       {
  427.          super.modelChanged(eventObj);
  428.       }
  429.    }
  430.    function isNodeVisible(node)
  431.    {
  432.       return this.getDisplayIndex(node) != undefined || this.getDisplayIndex(node.parentNode) != undefined && this.getIsOpen(node.parentNode);
  433.    }
  434.    function getFirstVisibleNode()
  435.    {
  436.       return this.__dataProvider.getItemAt(this.__vPosition);
  437.    }
  438.    function setFirstVisibleNode(node)
  439.    {
  440.       var _loc2_ = this.getDisplayIndex(node);
  441.       if(_loc2_ == undefined)
  442.       {
  443.          return undefined;
  444.       }
  445.       this.setVPosition(_loc2_);
  446.    }
  447.    function set firstVisibleNode(node)
  448.    {
  449.       this.setFirstVisibleNode(node);
  450.    }
  451.    function get firstVisibleNode()
  452.    {
  453.       return this.getFirstVisibleNode();
  454.    }
  455.    function set selectedNode(node)
  456.    {
  457.       var _loc2_ = this.getDisplayIndex(node);
  458.       if(_loc2_ >= 0)
  459.       {
  460.          this.setSelectedIndex(_loc2_);
  461.       }
  462.    }
  463.    function get selectedNode()
  464.    {
  465.       return this.getSelectedItem();
  466.    }
  467.    function set selectedNodes(nodeArray)
  468.    {
  469.       var _loc5_ = new Array();
  470.       var _loc3_ = undefined;
  471.       var _loc2_ = 0;
  472.       while(_loc2_ < nodeArray.length)
  473.       {
  474.          _loc3_ = this.getDisplayIndex(nodeArray[_loc2_]);
  475.          if(_loc3_ != undefined)
  476.          {
  477.             _loc5_.push(_loc3_);
  478.          }
  479.          _loc2_ = _loc2_ + 1;
  480.       }
  481.       this.setSelectedIndices(_loc5_);
  482.    }
  483.    function get selectedNodes()
  484.    {
  485.       return this.getSelectedItems();
  486.    }
  487.    function getDisplayList(node, removed)
  488.    {
  489.       var _loc5_ = new Array();
  490.       if(!this.isNodeVisible(node) || !this.getIsOpen(node))
  491.       {
  492.          return _loc5_;
  493.       }
  494.       var _loc6_ = this.getDisplayIndex(node);
  495.       var _loc3_ = new Array();
  496.       var _loc2_ = node.firstChild;
  497.       var _loc4_ = _loc2_ == undefined;
  498.       while(!_loc4_)
  499.       {
  500.          if(removed)
  501.          {
  502.             this.setDisplayIndex(_loc2_,undefined);
  503.          }
  504.          else
  505.          {
  506.             this.setDisplayIndex(_loc2_,_loc6_ = _loc6_ + 1);
  507.          }
  508.          _loc5_.push(_loc2_);
  509.          if(_loc2_.childNodes.length > 0 && this.getIsOpen(_loc2_))
  510.          {
  511.             if(_loc2_.nextSibling != undefined)
  512.             {
  513.                _loc3_.push(_loc2_.nextSibling);
  514.             }
  515.             _loc2_ = _loc2_.firstChild;
  516.          }
  517.          else if(_loc2_.nextSibling != undefined)
  518.          {
  519.             _loc2_ = _loc2_.nextSibling;
  520.          }
  521.          else if(_loc3_.length == 0)
  522.          {
  523.             _loc4_ = true;
  524.          }
  525.          else
  526.          {
  527.             _loc2_ = _loc3_.pop();
  528.          }
  529.       }
  530.       return _loc5_;
  531.    }
  532.    function getDisplayIndex(node)
  533.    {
  534.       return this.nodeIndices[node.getID()];
  535.    }
  536.    function setDisplayIndex(node, UID)
  537.    {
  538.       this.nodeIndices[node.getID()] = UID;
  539.    }
  540.    function keyDown(e)
  541.    {
  542.       if(this.isOpening)
  543.       {
  544.          return undefined;
  545.       }
  546.       var _loc3_ = this.__get__selectedNode();
  547.       if(e.ctrlKey)
  548.       {
  549.          super.keyDown(e);
  550.       }
  551.       else if(e.code == 32)
  552.       {
  553.          if(this.getIsBranch(_loc3_))
  554.          {
  555.             var _loc6_ = !this.getIsOpen(_loc3_);
  556.             this.setIsOpen(_loc3_,_loc6_,true,true);
  557.          }
  558.       }
  559.       else if(e.code == 37)
  560.       {
  561.          if(this.getIsOpen(_loc3_))
  562.          {
  563.             this.setIsOpen(_loc3_,false,true,true);
  564.          }
  565.          else
  566.          {
  567.             this.__set__selectedNode(_loc3_.parentNode);
  568.             this.dispatchEvent({type:"change"});
  569.             var _loc5_ = this.getDisplayIndex(this.__get__selectedNode());
  570.             if(_loc5_ < this.__vPosition)
  571.             {
  572.                this.setVPosition(_loc5_);
  573.             }
  574.          }
  575.       }
  576.       else if(e.code == 39)
  577.       {
  578.          if(this.getIsBranch(_loc3_))
  579.          {
  580.             if(this.getIsOpen(_loc3_))
  581.             {
  582.                this.__set__selectedNode(_loc3_.firstChild);
  583.                this.dispatchEvent({type:"change"});
  584.             }
  585.             else
  586.             {
  587.                this.setIsOpen(_loc3_,true,true,true);
  588.             }
  589.          }
  590.       }
  591.       else
  592.       {
  593.          super.keyDown(e);
  594.       }
  595.    }
  596.    function init()
  597.    {
  598.       super.init();
  599.       this.openNodes = new Object();
  600.       this.nodeIndices = new Object();
  601.    }
  602.    function invalidateStyle(propName)
  603.    {
  604.       if(this.isNewRowStyle[propName])
  605.       {
  606.          this.invUpdateControl = true;
  607.          this.invalidate();
  608.       }
  609.       super.invalidateStyle(propName);
  610.    }
  611.    function layoutContent(x, y, tW, tH, dW, dH)
  612.    {
  613.       var _loc5_ = 0;
  614.       var _loc6_ = 0;
  615.       var _loc3_ = 0;
  616.       while(_loc3_ < this.rows.length)
  617.       {
  618.          var _loc4_ = this.rows[_loc3_].getDepth();
  619.          if(_loc4_ > _loc5_)
  620.          {
  621.             _loc5_ = _loc4_;
  622.             _loc6_ = _loc3_;
  623.          }
  624.          _loc3_ = _loc3_ + 1;
  625.       }
  626.       var _loc7_ = _loc5_ + this.rows.length - _loc6_;
  627.       if(this.topRowZ < _loc7_)
  628.       {
  629.          this.topRowZ = _loc7_;
  630.       }
  631.       super.layoutContent(x,y,tW,tH,dW,dH);
  632.    }
  633.    function draw(Void)
  634.    {
  635.       super.draw();
  636.       if(this.eventPending != undefined)
  637.       {
  638.          this.dispatchEvent({type:(!this.getIsOpen(this.eventPending) ? "nodeClose" : "nodeOpen"),node:this.eventPending});
  639.          delete this.eventPending;
  640.       }
  641.    }
  642. }
  643.