TreeSelectionModel.js
上传用户:shuoshiled
上传日期:2018-01-28
资源大小:10124k
文件大小:9k
源码类别:

中间件编程

开发平台:

JavaScript

  1. /*!  * Ext JS Library 3.0.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ /**
  2.  * @class Ext.tree.DefaultSelectionModel
  3.  * @extends Ext.util.Observable
  4.  * The default single selection for a TreePanel.
  5.  */
  6. Ext.tree.DefaultSelectionModel = function(config){
  7.    this.selNode = null;
  8.    
  9.    this.addEvents(
  10.        /**
  11.         * @event selectionchange
  12.         * Fires when the selected node changes
  13.         * @param {DefaultSelectionModel} this
  14.         * @param {TreeNode} node the new selection
  15.         */
  16.        "selectionchange",
  17.        /**
  18.         * @event beforeselect
  19.         * Fires before the selected node changes, return false to cancel the change
  20.         * @param {DefaultSelectionModel} this
  21.         * @param {TreeNode} node the new selection
  22.         * @param {TreeNode} node the old selection
  23.         */
  24.        "beforeselect"
  25.    );
  26.     Ext.apply(this, config);
  27.     Ext.tree.DefaultSelectionModel.superclass.constructor.call(this);
  28. };
  29. Ext.extend(Ext.tree.DefaultSelectionModel, Ext.util.Observable, {
  30.     init : function(tree){
  31.         this.tree = tree;
  32.         tree.getTreeEl().on("keydown", this.onKeyDown, this);
  33.         tree.on("click", this.onNodeClick, this);
  34.     },
  35.     
  36.     onNodeClick : function(node, e){
  37.         this.select(node);
  38.     },
  39.     
  40.     /**
  41.      * Select a node.
  42.      * @param {TreeNode} node The node to select
  43.      * @return {TreeNode} The selected node
  44.      */
  45.     select : function(node){
  46.         var last = this.selNode;
  47.         if(node == last){
  48.             node.ui.onSelectedChange(true);
  49.         }else if(this.fireEvent('beforeselect', this, node, last) !== false){
  50.             if(last){
  51.                 last.ui.onSelectedChange(false);
  52.             }
  53.             this.selNode = node;
  54.             node.ui.onSelectedChange(true);
  55.             this.fireEvent("selectionchange", this, node, last);
  56.         }
  57.         return node;
  58.     },
  59.     
  60.     /**
  61.      * Deselect a node.
  62.      * @param {TreeNode} node The node to unselect
  63.      */
  64.     unselect : function(node){
  65.         if(this.selNode == node){
  66.             this.clearSelections();
  67.         }    
  68.     },
  69.     
  70.     /**
  71.      * Clear all selections
  72.      */
  73.     clearSelections : function(){
  74.         var n = this.selNode;
  75.         if(n){
  76.             n.ui.onSelectedChange(false);
  77.             this.selNode = null;
  78.             this.fireEvent("selectionchange", this, null);
  79.         }
  80.         return n;
  81.     },
  82.     
  83.     /**
  84.      * Get the selected node
  85.      * @return {TreeNode} The selected node
  86.      */
  87.     getSelectedNode : function(){
  88.         return this.selNode;    
  89.     },
  90.     
  91.     /**
  92.      * Returns true if the node is selected
  93.      * @param {TreeNode} node The node to check
  94.      * @return {Boolean}
  95.      */
  96.     isSelected : function(node){
  97.         return this.selNode == node;  
  98.     },
  99.     /**
  100.      * Selects the node above the selected node in the tree, intelligently walking the nodes
  101.      * @return TreeNode The new selection
  102.      */
  103.     selectPrevious : function(){
  104.         var s = this.selNode || this.lastSelNode;
  105.         if(!s){
  106.             return null;
  107.         }
  108.         var ps = s.previousSibling;
  109.         if(ps){
  110.             if(!ps.isExpanded() || ps.childNodes.length < 1){
  111.                 return this.select(ps);
  112.             } else{
  113.                 var lc = ps.lastChild;
  114.                 while(lc && lc.isExpanded() && lc.childNodes.length > 0){
  115.                     lc = lc.lastChild;
  116.                 }
  117.                 return this.select(lc);
  118.             }
  119.         } else if(s.parentNode && (this.tree.rootVisible || !s.parentNode.isRoot)){
  120.             return this.select(s.parentNode);
  121.         }
  122.         return null;
  123.     },
  124.     /**
  125.      * Selects the node above the selected node in the tree, intelligently walking the nodes
  126.      * @return TreeNode The new selection
  127.      */
  128.     selectNext : function(){
  129.         var s = this.selNode || this.lastSelNode;
  130.         if(!s){
  131.             return null;
  132.         }
  133.         if(s.firstChild && s.isExpanded()){
  134.              return this.select(s.firstChild);
  135.          }else if(s.nextSibling){
  136.              return this.select(s.nextSibling);
  137.          }else if(s.parentNode){
  138.             var newS = null;
  139.             s.parentNode.bubble(function(){
  140.                 if(this.nextSibling){
  141.                     newS = this.getOwnerTree().selModel.select(this.nextSibling);
  142.                     return false;
  143.                 }
  144.             });
  145.             return newS;
  146.          }
  147.         return null;
  148.     },
  149.     onKeyDown : function(e){
  150.         var s = this.selNode || this.lastSelNode;
  151.         // undesirable, but required
  152.         var sm = this;
  153.         if(!s){
  154.             return;
  155.         }
  156.         var k = e.getKey();
  157.         switch(k){
  158.              case e.DOWN:
  159.                  e.stopEvent();
  160.                  this.selectNext();
  161.              break;
  162.              case e.UP:
  163.                  e.stopEvent();
  164.                  this.selectPrevious();
  165.              break;
  166.              case e.RIGHT:
  167.                  e.preventDefault();
  168.                  if(s.hasChildNodes()){
  169.                      if(!s.isExpanded()){
  170.                          s.expand();
  171.                      }else if(s.firstChild){
  172.                          this.select(s.firstChild, e);
  173.                      }
  174.                  }
  175.              break;
  176.              case e.LEFT:
  177.                  e.preventDefault();
  178.                  if(s.hasChildNodes() && s.isExpanded()){
  179.                      s.collapse();
  180.                  }else if(s.parentNode && (this.tree.rootVisible || s.parentNode != this.tree.getRootNode())){
  181.                      this.select(s.parentNode, e);
  182.                  }
  183.              break;
  184.         };
  185.     }
  186. });
  187. /**
  188.  * @class Ext.tree.MultiSelectionModel
  189.  * @extends Ext.util.Observable
  190.  * Multi selection for a TreePanel.
  191.  */
  192. Ext.tree.MultiSelectionModel = function(config){
  193.    this.selNodes = [];
  194.    this.selMap = {};
  195.    this.addEvents(
  196.        /**
  197.         * @event selectionchange
  198.         * Fires when the selected nodes change
  199.         * @param {MultiSelectionModel} this
  200.         * @param {Array} nodes Array of the selected nodes
  201.         */
  202.        "selectionchange"
  203.    );
  204.     Ext.apply(this, config);
  205.     Ext.tree.MultiSelectionModel.superclass.constructor.call(this);
  206. };
  207. Ext.extend(Ext.tree.MultiSelectionModel, Ext.util.Observable, {
  208.     init : function(tree){
  209.         this.tree = tree;
  210.         tree.getTreeEl().on("keydown", this.onKeyDown, this);
  211.         tree.on("click", this.onNodeClick, this);
  212.     },
  213.     
  214.     onNodeClick : function(node, e){
  215.         if(e.ctrlKey && this.isSelected(node)){
  216.             this.unselect(node);
  217.         }else{
  218.             this.select(node, e, e.ctrlKey);
  219.         }
  220.     },
  221.     
  222.     /**
  223.      * Select a node.
  224.      * @param {TreeNode} node The node to select
  225.      * @param {EventObject} e (optional) An event associated with the selection
  226.      * @param {Boolean} keepExisting True to retain existing selections
  227.      * @return {TreeNode} The selected node
  228.      */
  229.     select : function(node, e, keepExisting){
  230.         if(keepExisting !== true){
  231.             this.clearSelections(true);
  232.         }
  233.         if(this.isSelected(node)){
  234.             this.lastSelNode = node;
  235.             return node;
  236.         }
  237.         this.selNodes.push(node);
  238.         this.selMap[node.id] = node;
  239.         this.lastSelNode = node;
  240.         node.ui.onSelectedChange(true);
  241.         this.fireEvent("selectionchange", this, this.selNodes);
  242.         return node;
  243.     },
  244.     
  245.     /**
  246.      * Deselect a node.
  247.      * @param {TreeNode} node The node to unselect
  248.      */
  249.     unselect : function(node){
  250.         if(this.selMap[node.id]){
  251.             node.ui.onSelectedChange(false);
  252.             var sn = this.selNodes;
  253.             var index = sn.indexOf(node);
  254.             if(index != -1){
  255.                 this.selNodes.splice(index, 1);
  256.             }
  257.             delete this.selMap[node.id];
  258.             this.fireEvent("selectionchange", this, this.selNodes);
  259.         }
  260.     },
  261.     
  262.     /**
  263.      * Clear all selections
  264.      */
  265.     clearSelections : function(suppressEvent){
  266.         var sn = this.selNodes;
  267.         if(sn.length > 0){
  268.             for(var i = 0, len = sn.length; i < len; i++){
  269.                 sn[i].ui.onSelectedChange(false);
  270.             }
  271.             this.selNodes = [];
  272.             this.selMap = {};
  273.             if(suppressEvent !== true){
  274.                 this.fireEvent("selectionchange", this, this.selNodes);
  275.             }
  276.         }
  277.     },
  278.     
  279.     /**
  280.      * Returns true if the node is selected
  281.      * @param {TreeNode} node The node to check
  282.      * @return {Boolean}
  283.      */
  284.     isSelected : function(node){
  285.         return this.selMap[node.id] ? true : false;  
  286.     },
  287.     
  288.     /**
  289.      * Returns an array of the selected nodes
  290.      * @return {Array}
  291.      */
  292.     getSelectedNodes : function(){
  293.         return this.selNodes;    
  294.     },
  295.     onKeyDown : Ext.tree.DefaultSelectionModel.prototype.onKeyDown,
  296.     selectNext : Ext.tree.DefaultSelectionModel.prototype.selectNext,
  297.     selectPrevious : Ext.tree.DefaultSelectionModel.prototype.selectPrevious
  298. });