Bienvenue sur PostGIS.fr

Bienvenue sur PostGIS.fr , le site de la communauté des utilisateurs francophones de PostGIS.

PostGIS ajoute le support d'objets géographique à la base de données PostgreSQL. En effet, PostGIS "spatialise" le serverur PostgreSQL, ce qui permet de l'utiliser comme une base de données SIG.

Maintenu à jour, en fonction de nos disponibilités et des diverses sorties des outils que nous testons, nous vous proposons l'ensemble de nos travaux publiés en langue française.

source: trunk/workshop-routing-foss4g/web/ext/src/widgets/tree/TreeSelectionModel.js @ 76

Revision 76, 9.9 KB checked in by djay, 12 years ago (diff)

Ajout du répertoire web

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