|
0
|
1 /*globals jQuery, define, module, exports, require, window, document, postMessage */
|
|
|
2 (function (factory) {
|
|
|
3 "use strict";
|
|
|
4 if (typeof define === 'function' && define.amd) {
|
|
|
5 define(['jquery'], factory);
|
|
|
6 }
|
|
|
7 else if(typeof module !== 'undefined' && module.exports) {
|
|
|
8 module.exports = factory(require('jquery'));
|
|
|
9 }
|
|
|
10 else {
|
|
|
11 factory(jQuery);
|
|
|
12 }
|
|
|
13 }(function ($, undefined) {
|
|
|
14 "use strict";
|
|
|
15 /*!
|
|
|
16 * jsTree 3.3.5
|
|
|
17 * http://jstree.com/
|
|
|
18 *
|
|
|
19 * Copyright (c) 2014 Ivan Bozhanov (http://vakata.com)
|
|
|
20 *
|
|
|
21 * Licensed same as jquery - under the terms of the MIT License
|
|
|
22 * http://www.opensource.org/licenses/mit-license.php
|
|
|
23 */
|
|
|
24 /*!
|
|
|
25 * if using jslint please allow for the jQuery global and use following options:
|
|
|
26 * jslint: loopfunc: true, browser: true, ass: true, bitwise: true, continue: true, nomen: true, plusplus: true, regexp: true, unparam: true, todo: true, white: true
|
|
|
27 */
|
|
|
28 /*jshint -W083 */
|
|
|
29
|
|
|
30 // prevent another load? maybe there is a better way?
|
|
|
31 if($.jstree) {
|
|
|
32 return;
|
|
|
33 }
|
|
|
34
|
|
|
35 /**
|
|
|
36 * ### jsTree core functionality
|
|
|
37 */
|
|
|
38
|
|
|
39 // internal variables
|
|
|
40 var instance_counter = 0,
|
|
|
41 ccp_node = false,
|
|
|
42 ccp_mode = false,
|
|
|
43 ccp_inst = false,
|
|
|
44 themes_loaded = [],
|
|
|
45 src = $('script:last').attr('src'),
|
|
|
46 document = window.document; // local variable is always faster to access then a global
|
|
|
47
|
|
|
48 /**
|
|
|
49 * holds all jstree related functions and variables, including the actual class and methods to create, access and manipulate instances.
|
|
|
50 * @name $.jstree
|
|
|
51 */
|
|
|
52 $.jstree = {
|
|
|
53 /**
|
|
|
54 * specifies the jstree version in use
|
|
|
55 * @name $.jstree.version
|
|
|
56 */
|
|
|
57 version : '3.3.5',
|
|
|
58 /**
|
|
|
59 * holds all the default options used when creating new instances
|
|
|
60 * @name $.jstree.defaults
|
|
|
61 */
|
|
|
62 defaults : {
|
|
|
63 /**
|
|
|
64 * configure which plugins will be active on an instance. Should be an array of strings, where each element is a plugin name. The default is `[]`
|
|
|
65 * @name $.jstree.defaults.plugins
|
|
|
66 */
|
|
|
67 plugins : []
|
|
|
68 },
|
|
|
69 /**
|
|
|
70 * stores all loaded jstree plugins (used internally)
|
|
|
71 * @name $.jstree.plugins
|
|
|
72 */
|
|
|
73 plugins : {},
|
|
|
74 path : src && src.indexOf('/') !== -1 ? src.replace(/\/[^\/]+$/,'') : '',
|
|
|
75 idregex : /[\\:&!^|()\[\]<>@*'+~#";.,=\- \/${}%?`]/g,
|
|
|
76 root : '#'
|
|
|
77 };
|
|
|
78
|
|
|
79 /**
|
|
|
80 * creates a jstree instance
|
|
|
81 * @name $.jstree.create(el [, options])
|
|
|
82 * @param {DOMElement|jQuery|String} el the element to create the instance on, can be jQuery extended or a selector
|
|
|
83 * @param {Object} options options for this instance (extends `$.jstree.defaults`)
|
|
|
84 * @return {jsTree} the new instance
|
|
|
85 */
|
|
|
86 $.jstree.create = function (el, options) {
|
|
|
87 var tmp = new $.jstree.core(++instance_counter),
|
|
|
88 opt = options;
|
|
|
89 options = $.extend(true, {}, $.jstree.defaults, options);
|
|
|
90 if(opt && opt.plugins) {
|
|
|
91 options.plugins = opt.plugins;
|
|
|
92 }
|
|
|
93 $.each(options.plugins, function (i, k) {
|
|
|
94 if(i !== 'core') {
|
|
|
95 tmp = tmp.plugin(k, options[k]);
|
|
|
96 }
|
|
|
97 });
|
|
|
98 $(el).data('jstree', tmp);
|
|
|
99 tmp.init(el, options);
|
|
|
100 return tmp;
|
|
|
101 };
|
|
|
102 /**
|
|
|
103 * remove all traces of jstree from the DOM and destroy all instances
|
|
|
104 * @name $.jstree.destroy()
|
|
|
105 */
|
|
|
106 $.jstree.destroy = function () {
|
|
|
107 $('.jstree:jstree').jstree('destroy');
|
|
|
108 $(document).off('.jstree');
|
|
|
109 };
|
|
|
110 /**
|
|
|
111 * the jstree class constructor, used only internally
|
|
|
112 * @private
|
|
|
113 * @name $.jstree.core(id)
|
|
|
114 * @param {Number} id this instance's index
|
|
|
115 */
|
|
|
116 $.jstree.core = function (id) {
|
|
|
117 this._id = id;
|
|
|
118 this._cnt = 0;
|
|
|
119 this._wrk = null;
|
|
|
120 this._data = {
|
|
|
121 core : {
|
|
|
122 themes : {
|
|
|
123 name : false,
|
|
|
124 dots : false,
|
|
|
125 icons : false,
|
|
|
126 ellipsis : false
|
|
|
127 },
|
|
|
128 selected : [],
|
|
|
129 last_error : {},
|
|
|
130 working : false,
|
|
|
131 worker_queue : [],
|
|
|
132 focused : null
|
|
|
133 }
|
|
|
134 };
|
|
|
135 };
|
|
|
136 /**
|
|
|
137 * get a reference to an existing instance
|
|
|
138 *
|
|
|
139 * __Examples__
|
|
|
140 *
|
|
|
141 * // provided a container with an ID of "tree", and a nested node with an ID of "branch"
|
|
|
142 * // all of there will return the same instance
|
|
|
143 * $.jstree.reference('tree');
|
|
|
144 * $.jstree.reference('#tree');
|
|
|
145 * $.jstree.reference($('#tree'));
|
|
|
146 * $.jstree.reference(document.getElementByID('tree'));
|
|
|
147 * $.jstree.reference('branch');
|
|
|
148 * $.jstree.reference('#branch');
|
|
|
149 * $.jstree.reference($('#branch'));
|
|
|
150 * $.jstree.reference(document.getElementByID('branch'));
|
|
|
151 *
|
|
|
152 * @name $.jstree.reference(needle)
|
|
|
153 * @param {DOMElement|jQuery|String} needle
|
|
|
154 * @return {jsTree|null} the instance or `null` if not found
|
|
|
155 */
|
|
|
156 $.jstree.reference = function (needle) {
|
|
|
157 var tmp = null,
|
|
|
158 obj = null;
|
|
|
159 if(needle && needle.id && (!needle.tagName || !needle.nodeType)) { needle = needle.id; }
|
|
|
160
|
|
|
161 if(!obj || !obj.length) {
|
|
|
162 try { obj = $(needle); } catch (ignore) { }
|
|
|
163 }
|
|
|
164 if(!obj || !obj.length) {
|
|
|
165 try { obj = $('#' + needle.replace($.jstree.idregex,'\\$&')); } catch (ignore) { }
|
|
|
166 }
|
|
|
167 if(obj && obj.length && (obj = obj.closest('.jstree')).length && (obj = obj.data('jstree'))) {
|
|
|
168 tmp = obj;
|
|
|
169 }
|
|
|
170 else {
|
|
|
171 $('.jstree').each(function () {
|
|
|
172 var inst = $(this).data('jstree');
|
|
|
173 if(inst && inst._model.data[needle]) {
|
|
|
174 tmp = inst;
|
|
|
175 return false;
|
|
|
176 }
|
|
|
177 });
|
|
|
178 }
|
|
|
179 return tmp;
|
|
|
180 };
|
|
|
181 /**
|
|
|
182 * Create an instance, get an instance or invoke a command on a instance.
|
|
|
183 *
|
|
|
184 * If there is no instance associated with the current node a new one is created and `arg` is used to extend `$.jstree.defaults` for this new instance. There would be no return value (chaining is not broken).
|
|
|
185 *
|
|
|
186 * If there is an existing instance and `arg` is a string the command specified by `arg` is executed on the instance, with any additional arguments passed to the function. If the function returns a value it will be returned (chaining could break depending on function).
|
|
|
187 *
|
|
|
188 * If there is an existing instance and `arg` is not a string the instance itself is returned (similar to `$.jstree.reference`).
|
|
|
189 *
|
|
|
190 * In any other case - nothing is returned and chaining is not broken.
|
|
|
191 *
|
|
|
192 * __Examples__
|
|
|
193 *
|
|
|
194 * $('#tree1').jstree(); // creates an instance
|
|
|
195 * $('#tree2').jstree({ plugins : [] }); // create an instance with some options
|
|
|
196 * $('#tree1').jstree('open_node', '#branch_1'); // call a method on an existing instance, passing additional arguments
|
|
|
197 * $('#tree2').jstree(); // get an existing instance (or create an instance)
|
|
|
198 * $('#tree2').jstree(true); // get an existing instance (will not create new instance)
|
|
|
199 * $('#branch_1').jstree().select_node('#branch_1'); // get an instance (using a nested element and call a method)
|
|
|
200 *
|
|
|
201 * @name $().jstree([arg])
|
|
|
202 * @param {String|Object} arg
|
|
|
203 * @return {Mixed}
|
|
|
204 */
|
|
|
205 $.fn.jstree = function (arg) {
|
|
|
206 // check for string argument
|
|
|
207 var is_method = (typeof arg === 'string'),
|
|
|
208 args = Array.prototype.slice.call(arguments, 1),
|
|
|
209 result = null;
|
|
|
210 if(arg === true && !this.length) { return false; }
|
|
|
211 this.each(function () {
|
|
|
212 // get the instance (if there is one) and method (if it exists)
|
|
|
213 var instance = $.jstree.reference(this),
|
|
|
214 method = is_method && instance ? instance[arg] : null;
|
|
|
215 // if calling a method, and method is available - execute on the instance
|
|
|
216 result = is_method && method ?
|
|
|
217 method.apply(instance, args) :
|
|
|
218 null;
|
|
|
219 // if there is no instance and no method is being called - create one
|
|
|
220 if(!instance && !is_method && (arg === undefined || $.isPlainObject(arg))) {
|
|
|
221 $.jstree.create(this, arg);
|
|
|
222 }
|
|
|
223 // if there is an instance and no method is called - return the instance
|
|
|
224 if( (instance && !is_method) || arg === true ) {
|
|
|
225 result = instance || false;
|
|
|
226 }
|
|
|
227 // if there was a method call which returned a result - break and return the value
|
|
|
228 if(result !== null && result !== undefined) {
|
|
|
229 return false;
|
|
|
230 }
|
|
|
231 });
|
|
|
232 // if there was a method call with a valid return value - return that, otherwise continue the chain
|
|
|
233 return result !== null && result !== undefined ?
|
|
|
234 result : this;
|
|
|
235 };
|
|
|
236 /**
|
|
|
237 * used to find elements containing an instance
|
|
|
238 *
|
|
|
239 * __Examples__
|
|
|
240 *
|
|
|
241 * $('div:jstree').each(function () {
|
|
|
242 * $(this).jstree('destroy');
|
|
|
243 * });
|
|
|
244 *
|
|
|
245 * @name $(':jstree')
|
|
|
246 * @return {jQuery}
|
|
|
247 */
|
|
|
248 $.expr.pseudos.jstree = $.expr.createPseudo(function(search) {
|
|
|
249 return function(a) {
|
|
|
250 return $(a).hasClass('jstree') &&
|
|
|
251 $(a).data('jstree') !== undefined;
|
|
|
252 };
|
|
|
253 });
|
|
|
254
|
|
|
255 /**
|
|
|
256 * stores all defaults for the core
|
|
|
257 * @name $.jstree.defaults.core
|
|
|
258 */
|
|
|
259 $.jstree.defaults.core = {
|
|
|
260 /**
|
|
|
261 * data configuration
|
|
|
262 *
|
|
|
263 * If left as `false` the HTML inside the jstree container element is used to populate the tree (that should be an unordered list with list items).
|
|
|
264 *
|
|
|
265 * You can also pass in a HTML string or a JSON array here.
|
|
|
266 *
|
|
|
267 * It is possible to pass in a standard jQuery-like AJAX config and jstree will automatically determine if the response is JSON or HTML and use that to populate the tree.
|
|
|
268 * In addition to the standard jQuery ajax options here you can suppy functions for `data` and `url`, the functions will be run in the current instance's scope and a param will be passed indicating which node is being loaded, the return value of those functions will be used.
|
|
|
269 *
|
|
|
270 * The last option is to specify a function, that function will receive the node being loaded as argument and a second param which is a function which should be called with the result.
|
|
|
271 *
|
|
|
272 * __Examples__
|
|
|
273 *
|
|
|
274 * // AJAX
|
|
|
275 * $('#tree').jstree({
|
|
|
276 * 'core' : {
|
|
|
277 * 'data' : {
|
|
|
278 * 'url' : '/get/children/',
|
|
|
279 * 'data' : function (node) {
|
|
|
280 * return { 'id' : node.id };
|
|
|
281 * }
|
|
|
282 * }
|
|
|
283 * });
|
|
|
284 *
|
|
|
285 * // direct data
|
|
|
286 * $('#tree').jstree({
|
|
|
287 * 'core' : {
|
|
|
288 * 'data' : [
|
|
|
289 * 'Simple root node',
|
|
|
290 * {
|
|
|
291 * 'id' : 'node_2',
|
|
|
292 * 'text' : 'Root node with options',
|
|
|
293 * 'state' : { 'opened' : true, 'selected' : true },
|
|
|
294 * 'children' : [ { 'text' : 'Child 1' }, 'Child 2']
|
|
|
295 * }
|
|
|
296 * ]
|
|
|
297 * }
|
|
|
298 * });
|
|
|
299 *
|
|
|
300 * // function
|
|
|
301 * $('#tree').jstree({
|
|
|
302 * 'core' : {
|
|
|
303 * 'data' : function (obj, callback) {
|
|
|
304 * callback.call(this, ['Root 1', 'Root 2']);
|
|
|
305 * }
|
|
|
306 * });
|
|
|
307 *
|
|
|
308 * @name $.jstree.defaults.core.data
|
|
|
309 */
|
|
|
310 data : false,
|
|
|
311 /**
|
|
|
312 * configure the various strings used throughout the tree
|
|
|
313 *
|
|
|
314 * You can use an object where the key is the string you need to replace and the value is your replacement.
|
|
|
315 * Another option is to specify a function which will be called with an argument of the needed string and should return the replacement.
|
|
|
316 * If left as `false` no replacement is made.
|
|
|
317 *
|
|
|
318 * __Examples__
|
|
|
319 *
|
|
|
320 * $('#tree').jstree({
|
|
|
321 * 'core' : {
|
|
|
322 * 'strings' : {
|
|
|
323 * 'Loading ...' : 'Please wait ...'
|
|
|
324 * }
|
|
|
325 * }
|
|
|
326 * });
|
|
|
327 *
|
|
|
328 * @name $.jstree.defaults.core.strings
|
|
|
329 */
|
|
|
330 strings : false,
|
|
|
331 /**
|
|
|
332 * determines what happens when a user tries to modify the structure of the tree
|
|
|
333 * If left as `false` all operations like create, rename, delete, move or copy are prevented.
|
|
|
334 * You can set this to `true` to allow all interactions or use a function to have better control.
|
|
|
335 *
|
|
|
336 * __Examples__
|
|
|
337 *
|
|
|
338 * $('#tree').jstree({
|
|
|
339 * 'core' : {
|
|
|
340 * 'check_callback' : function (operation, node, node_parent, node_position, more) {
|
|
|
341 * // operation can be 'create_node', 'rename_node', 'delete_node', 'move_node', 'copy_node' or 'edit'
|
|
|
342 * // in case of 'rename_node' node_position is filled with the new node name
|
|
|
343 * return operation === 'rename_node' ? true : false;
|
|
|
344 * }
|
|
|
345 * }
|
|
|
346 * });
|
|
|
347 *
|
|
|
348 * @name $.jstree.defaults.core.check_callback
|
|
|
349 */
|
|
|
350 check_callback : false,
|
|
|
351 /**
|
|
|
352 * a callback called with a single object parameter in the instance's scope when something goes wrong (operation prevented, ajax failed, etc)
|
|
|
353 * @name $.jstree.defaults.core.error
|
|
|
354 */
|
|
|
355 error : $.noop,
|
|
|
356 /**
|
|
|
357 * the open / close animation duration in milliseconds - set this to `false` to disable the animation (default is `200`)
|
|
|
358 * @name $.jstree.defaults.core.animation
|
|
|
359 */
|
|
|
360 animation : 200,
|
|
|
361 /**
|
|
|
362 * a boolean indicating if multiple nodes can be selected
|
|
|
363 * @name $.jstree.defaults.core.multiple
|
|
|
364 */
|
|
|
365 multiple : true,
|
|
|
366 /**
|
|
|
367 * theme configuration object
|
|
|
368 * @name $.jstree.defaults.core.themes
|
|
|
369 */
|
|
|
370 themes : {
|
|
|
371 /**
|
|
|
372 * the name of the theme to use (if left as `false` the default theme is used)
|
|
|
373 * @name $.jstree.defaults.core.themes.name
|
|
|
374 */
|
|
|
375 name : false,
|
|
|
376 /**
|
|
|
377 * the URL of the theme's CSS file, leave this as `false` if you have manually included the theme CSS (recommended). You can set this to `true` too which will try to autoload the theme.
|
|
|
378 * @name $.jstree.defaults.core.themes.url
|
|
|
379 */
|
|
|
380 url : false,
|
|
|
381 /**
|
|
|
382 * the location of all jstree themes - only used if `url` is set to `true`
|
|
|
383 * @name $.jstree.defaults.core.themes.dir
|
|
|
384 */
|
|
|
385 dir : false,
|
|
|
386 /**
|
|
|
387 * a boolean indicating if connecting dots are shown
|
|
|
388 * @name $.jstree.defaults.core.themes.dots
|
|
|
389 */
|
|
|
390 dots : true,
|
|
|
391 /**
|
|
|
392 * a boolean indicating if node icons are shown
|
|
|
393 * @name $.jstree.defaults.core.themes.icons
|
|
|
394 */
|
|
|
395 icons : true,
|
|
|
396 /**
|
|
|
397 * a boolean indicating if node ellipsis should be shown - this only works with a fixed with on the container
|
|
|
398 * @name $.jstree.defaults.core.themes.ellipsis
|
|
|
399 */
|
|
|
400 ellipsis : false,
|
|
|
401 /**
|
|
|
402 * a boolean indicating if the tree background is striped
|
|
|
403 * @name $.jstree.defaults.core.themes.stripes
|
|
|
404 */
|
|
|
405 stripes : false,
|
|
|
406 /**
|
|
|
407 * a string (or boolean `false`) specifying the theme variant to use (if the theme supports variants)
|
|
|
408 * @name $.jstree.defaults.core.themes.variant
|
|
|
409 */
|
|
|
410 variant : false,
|
|
|
411 /**
|
|
|
412 * a boolean specifying if a reponsive version of the theme should kick in on smaller screens (if the theme supports it). Defaults to `false`.
|
|
|
413 * @name $.jstree.defaults.core.themes.responsive
|
|
|
414 */
|
|
|
415 responsive : false
|
|
|
416 },
|
|
|
417 /**
|
|
|
418 * if left as `true` all parents of all selected nodes will be opened once the tree loads (so that all selected nodes are visible to the user)
|
|
|
419 * @name $.jstree.defaults.core.expand_selected_onload
|
|
|
420 */
|
|
|
421 expand_selected_onload : true,
|
|
|
422 /**
|
|
|
423 * if left as `true` web workers will be used to parse incoming JSON data where possible, so that the UI will not be blocked by large requests. Workers are however about 30% slower. Defaults to `true`
|
|
|
424 * @name $.jstree.defaults.core.worker
|
|
|
425 */
|
|
|
426 worker : true,
|
|
|
427 /**
|
|
|
428 * Force node text to plain text (and escape HTML). Defaults to `false`
|
|
|
429 * @name $.jstree.defaults.core.force_text
|
|
|
430 */
|
|
|
431 force_text : false,
|
|
|
432 /**
|
|
|
433 * Should the node should be toggled if the text is double clicked . Defaults to `true`
|
|
|
434 * @name $.jstree.defaults.core.dblclick_toggle
|
|
|
435 */
|
|
|
436 dblclick_toggle : true,
|
|
|
437 /**
|
|
|
438 * Should the loaded nodes be part of the state. Defaults to `false`
|
|
|
439 * @name $.jstree.defaults.core.loaded_state
|
|
|
440 */
|
|
|
441 loaded_state : false,
|
|
|
442 /**
|
|
|
443 * Should the last active node be focused when the tree container is blurred and the focused again. This helps working with screen readers. Defaults to `true`
|
|
|
444 * @name $.jstree.defaults.core.restore_focus
|
|
|
445 */
|
|
|
446 restore_focus : true,
|
|
|
447 /**
|
|
|
448 * Default keyboard shortcuts (an object where each key is the button name or combo - like 'enter', 'ctrl-space', 'p', etc and the value is the function to execute in the instance's scope)
|
|
|
449 * @name $.jstree.defaults.core.keyboard
|
|
|
450 */
|
|
|
451 keyboard : {
|
|
|
452 'ctrl-space': function (e) {
|
|
|
453 // aria defines space only with Ctrl
|
|
|
454 e.type = "click";
|
|
|
455 $(e.currentTarget).trigger(e);
|
|
|
456 },
|
|
|
457 'enter': function (e) {
|
|
|
458 // enter
|
|
|
459 e.type = "click";
|
|
|
460 $(e.currentTarget).trigger(e);
|
|
|
461 },
|
|
|
462 'left': function (e) {
|
|
|
463 // left
|
|
|
464 e.preventDefault();
|
|
|
465 if(this.is_open(e.currentTarget)) {
|
|
|
466 this.close_node(e.currentTarget);
|
|
|
467 }
|
|
|
468 else {
|
|
|
469 var o = this.get_parent(e.currentTarget);
|
|
|
470 if(o && o.id !== $.jstree.root) { this.get_node(o, true).children('.jstree-anchor').focus(); }
|
|
|
471 }
|
|
|
472 },
|
|
|
473 'up': function (e) {
|
|
|
474 // up
|
|
|
475 e.preventDefault();
|
|
|
476 var o = this.get_prev_dom(e.currentTarget);
|
|
|
477 if(o && o.length) { o.children('.jstree-anchor').focus(); }
|
|
|
478 },
|
|
|
479 'right': function (e) {
|
|
|
480 // right
|
|
|
481 e.preventDefault();
|
|
|
482 if(this.is_closed(e.currentTarget)) {
|
|
|
483 this.open_node(e.currentTarget, function (o) { this.get_node(o, true).children('.jstree-anchor').focus(); });
|
|
|
484 }
|
|
|
485 else if (this.is_open(e.currentTarget)) {
|
|
|
486 var o = this.get_node(e.currentTarget, true).children('.jstree-children')[0];
|
|
|
487 if(o) { $(this._firstChild(o)).children('.jstree-anchor').focus(); }
|
|
|
488 }
|
|
|
489 },
|
|
|
490 'down': function (e) {
|
|
|
491 // down
|
|
|
492 e.preventDefault();
|
|
|
493 var o = this.get_next_dom(e.currentTarget);
|
|
|
494 if(o && o.length) { o.children('.jstree-anchor').focus(); }
|
|
|
495 },
|
|
|
496 '*': function (e) {
|
|
|
497 // aria defines * on numpad as open_all - not very common
|
|
|
498 this.open_all();
|
|
|
499 },
|
|
|
500 'home': function (e) {
|
|
|
501 // home
|
|
|
502 e.preventDefault();
|
|
|
503 var o = this._firstChild(this.get_container_ul()[0]);
|
|
|
504 if(o) { $(o).children('.jstree-anchor').filter(':visible').focus(); }
|
|
|
505 },
|
|
|
506 'end': function (e) {
|
|
|
507 // end
|
|
|
508 e.preventDefault();
|
|
|
509 this.element.find('.jstree-anchor').filter(':visible').last().focus();
|
|
|
510 },
|
|
|
511 'f2': function (e) {
|
|
|
512 // f2 - safe to include - if check_callback is false it will fail
|
|
|
513 e.preventDefault();
|
|
|
514 this.edit(e.currentTarget);
|
|
|
515 }
|
|
|
516 }
|
|
|
517 };
|
|
|
518 $.jstree.core.prototype = {
|
|
|
519 /**
|
|
|
520 * used to decorate an instance with a plugin. Used internally.
|
|
|
521 * @private
|
|
|
522 * @name plugin(deco [, opts])
|
|
|
523 * @param {String} deco the plugin to decorate with
|
|
|
524 * @param {Object} opts options for the plugin
|
|
|
525 * @return {jsTree}
|
|
|
526 */
|
|
|
527 plugin : function (deco, opts) {
|
|
|
528 var Child = $.jstree.plugins[deco];
|
|
|
529 if(Child) {
|
|
|
530 this._data[deco] = {};
|
|
|
531 Child.prototype = this;
|
|
|
532 return new Child(opts, this);
|
|
|
533 }
|
|
|
534 return this;
|
|
|
535 },
|
|
|
536 /**
|
|
|
537 * initialize the instance. Used internally.
|
|
|
538 * @private
|
|
|
539 * @name init(el, optons)
|
|
|
540 * @param {DOMElement|jQuery|String} el the element we are transforming
|
|
|
541 * @param {Object} options options for this instance
|
|
|
542 * @trigger init.jstree, loading.jstree, loaded.jstree, ready.jstree, changed.jstree
|
|
|
543 */
|
|
|
544 init : function (el, options) {
|
|
|
545 this._model = {
|
|
|
546 data : {},
|
|
|
547 changed : [],
|
|
|
548 force_full_redraw : false,
|
|
|
549 redraw_timeout : false,
|
|
|
550 default_state : {
|
|
|
551 loaded : true,
|
|
|
552 opened : false,
|
|
|
553 selected : false,
|
|
|
554 disabled : false
|
|
|
555 }
|
|
|
556 };
|
|
|
557 this._model.data[$.jstree.root] = {
|
|
|
558 id : $.jstree.root,
|
|
|
559 parent : null,
|
|
|
560 parents : [],
|
|
|
561 children : [],
|
|
|
562 children_d : [],
|
|
|
563 state : { loaded : false }
|
|
|
564 };
|
|
|
565
|
|
|
566 this.element = $(el).addClass('jstree jstree-' + this._id);
|
|
|
567 this.settings = options;
|
|
|
568
|
|
|
569 this._data.core.ready = false;
|
|
|
570 this._data.core.loaded = false;
|
|
|
571 this._data.core.rtl = (this.element.css("direction") === "rtl");
|
|
|
572 this.element[this._data.core.rtl ? 'addClass' : 'removeClass']("jstree-rtl");
|
|
|
573 this.element.attr('role','tree');
|
|
|
574 if(this.settings.core.multiple) {
|
|
|
575 this.element.attr('aria-multiselectable', true);
|
|
|
576 }
|
|
|
577 if(!this.element.attr('tabindex')) {
|
|
|
578 this.element.attr('tabindex','0');
|
|
|
579 }
|
|
|
580
|
|
|
581 this.bind();
|
|
|
582 /**
|
|
|
583 * triggered after all events are bound
|
|
|
584 * @event
|
|
|
585 * @name init.jstree
|
|
|
586 */
|
|
|
587 this.trigger("init");
|
|
|
588
|
|
|
589 this._data.core.original_container_html = this.element.find(" > ul > li").clone(true);
|
|
|
590 this._data.core.original_container_html
|
|
|
591 .find("li").addBack()
|
|
|
592 .contents().filter(function() {
|
|
|
593 return this.nodeType === 3 && (!this.nodeValue || /^\s+$/.test(this.nodeValue));
|
|
|
594 })
|
|
|
595 .remove();
|
|
|
596 this.element.html("<"+"ul class='jstree-container-ul jstree-children' role='group'><"+"li id='j"+this._id+"_loading' class='jstree-initial-node jstree-loading jstree-leaf jstree-last' role='tree-item'><i class='jstree-icon jstree-ocl'></i><"+"a class='jstree-anchor' href='#'><i class='jstree-icon jstree-themeicon-hidden'></i>" + this.get_string("Loading ...") + "</a></li></ul>");
|
|
|
597 this.element.attr('aria-activedescendant','j' + this._id + '_loading');
|
|
|
598 this._data.core.li_height = this.get_container_ul().children("li").first().outerHeight() || 24;
|
|
|
599 this._data.core.node = this._create_prototype_node();
|
|
|
600 /**
|
|
|
601 * triggered after the loading text is shown and before loading starts
|
|
|
602 * @event
|
|
|
603 * @name loading.jstree
|
|
|
604 */
|
|
|
605 this.trigger("loading");
|
|
|
606 this.load_node($.jstree.root);
|
|
|
607 },
|
|
|
608 /**
|
|
|
609 * destroy an instance
|
|
|
610 * @name destroy()
|
|
|
611 * @param {Boolean} keep_html if not set to `true` the container will be emptied, otherwise the current DOM elements will be kept intact
|
|
|
612 */
|
|
|
613 destroy : function (keep_html) {
|
|
|
614 /**
|
|
|
615 * triggered before the tree is destroyed
|
|
|
616 * @event
|
|
|
617 * @name destroy.jstree
|
|
|
618 */
|
|
|
619 this.trigger("destroy");
|
|
|
620 if(this._wrk) {
|
|
|
621 try {
|
|
|
622 window.URL.revokeObjectURL(this._wrk);
|
|
|
623 this._wrk = null;
|
|
|
624 }
|
|
|
625 catch (ignore) { }
|
|
|
626 }
|
|
|
627 if(!keep_html) { this.element.empty(); }
|
|
|
628 this.teardown();
|
|
|
629 },
|
|
|
630 /**
|
|
|
631 * Create a prototype node
|
|
|
632 * @name _create_prototype_node()
|
|
|
633 * @return {DOMElement}
|
|
|
634 */
|
|
|
635 _create_prototype_node : function () {
|
|
|
636 var _node = document.createElement('LI'), _temp1, _temp2;
|
|
|
637 _node.setAttribute('role', 'treeitem');
|
|
|
638 _temp1 = document.createElement('I');
|
|
|
639 _temp1.className = 'jstree-icon jstree-ocl';
|
|
|
640 _temp1.setAttribute('role', 'presentation');
|
|
|
641 _node.appendChild(_temp1);
|
|
|
642 _temp1 = document.createElement('A');
|
|
|
643 _temp1.className = 'jstree-anchor';
|
|
|
644 _temp1.setAttribute('href','#');
|
|
|
645 _temp1.setAttribute('tabindex','-1');
|
|
|
646 _temp2 = document.createElement('I');
|
|
|
647 _temp2.className = 'jstree-icon jstree-themeicon';
|
|
|
648 _temp2.setAttribute('role', 'presentation');
|
|
|
649 _temp1.appendChild(_temp2);
|
|
|
650 _node.appendChild(_temp1);
|
|
|
651 _temp1 = _temp2 = null;
|
|
|
652
|
|
|
653 return _node;
|
|
|
654 },
|
|
|
655 _kbevent_to_func : function (e) {
|
|
|
656 var keys = {
|
|
|
657 8: "Backspace", 9: "Tab", 13: "Return", 19: "Pause", 27: "Esc",
|
|
|
658 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End", 36: "Home",
|
|
|
659 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "Print", 45: "Insert",
|
|
|
660 46: "Delete", 96: "Numpad0", 97: "Numpad1", 98: "Numpad2", 99 : "Numpad3",
|
|
|
661 100: "Numpad4", 101: "Numpad5", 102: "Numpad6", 103: "Numpad7",
|
|
|
662 104: "Numpad8", 105: "Numpad9", '-13': "NumpadEnter", 112: "F1",
|
|
|
663 113: "F2", 114: "F3", 115: "F4", 116: "F5", 117: "F6", 118: "F7",
|
|
|
664 119: "F8", 120: "F9", 121: "F10", 122: "F11", 123: "F12", 144: "Numlock",
|
|
|
665 145: "Scrolllock", 16: 'Shift', 17: 'Ctrl', 18: 'Alt',
|
|
|
666 48: '0', 49: '1', 50: '2', 51: '3', 52: '4', 53: '5',
|
|
|
667 54: '6', 55: '7', 56: '8', 57: '9', 59: ';', 61: '=', 65: 'a',
|
|
|
668 66: 'b', 67: 'c', 68: 'd', 69: 'e', 70: 'f', 71: 'g', 72: 'h',
|
|
|
669 73: 'i', 74: 'j', 75: 'k', 76: 'l', 77: 'm', 78: 'n', 79: 'o',
|
|
|
670 80: 'p', 81: 'q', 82: 'r', 83: 's', 84: 't', 85: 'u', 86: 'v',
|
|
|
671 87: 'w', 88: 'x', 89: 'y', 90: 'z', 107: '+', 109: '-', 110: '.',
|
|
|
672 186: ';', 187: '=', 188: ',', 189: '-', 190: '.', 191: '/', 192: '`',
|
|
|
673 219: '[', 220: '\\',221: ']', 222: "'", 111: '/', 106: '*', 173: '-'
|
|
|
674 };
|
|
|
675 var parts = [];
|
|
|
676 if (e.ctrlKey) { parts.push('ctrl'); }
|
|
|
677 if (e.altKey) { parts.push('alt'); }
|
|
|
678 if (e.shiftKey) { parts.push('shift'); }
|
|
|
679 parts.push(keys[e.which] || e.which);
|
|
|
680 parts = parts.sort().join('-').toLowerCase();
|
|
|
681
|
|
|
682 var kb = this.settings.core.keyboard, i, tmp;
|
|
|
683 for (i in kb) {
|
|
|
684 if (kb.hasOwnProperty(i)) {
|
|
|
685 tmp = i;
|
|
|
686 if (tmp !== '-' && tmp !== '+') {
|
|
|
687 tmp = tmp.replace('--', '-MINUS').replace('+-', '-MINUS').replace('++', '-PLUS').replace('-+', '-PLUS');
|
|
|
688 tmp = tmp.split(/-|\+/).sort().join('-').replace('MINUS', '-').replace('PLUS', '+').toLowerCase();
|
|
|
689 }
|
|
|
690 if (tmp === parts) {
|
|
|
691 return kb[i];
|
|
|
692 }
|
|
|
693 }
|
|
|
694 }
|
|
|
695 return null;
|
|
|
696 },
|
|
|
697 /**
|
|
|
698 * part of the destroying of an instance. Used internally.
|
|
|
699 * @private
|
|
|
700 * @name teardown()
|
|
|
701 */
|
|
|
702 teardown : function () {
|
|
|
703 this.unbind();
|
|
|
704 this.element
|
|
|
705 .removeClass('jstree')
|
|
|
706 .removeData('jstree')
|
|
|
707 .find("[class^='jstree']")
|
|
|
708 .addBack()
|
|
|
709 .attr("class", function () { return this.className.replace(/jstree[^ ]*|$/ig,''); });
|
|
|
710 this.element = null;
|
|
|
711 },
|
|
|
712 /**
|
|
|
713 * bind all events. Used internally.
|
|
|
714 * @private
|
|
|
715 * @name bind()
|
|
|
716 */
|
|
|
717 bind : function () {
|
|
|
718 var word = '',
|
|
|
719 tout = null,
|
|
|
720 was_click = 0;
|
|
|
721 this.element
|
|
|
722 .on("dblclick.jstree", function (e) {
|
|
|
723 if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }
|
|
|
724 if(document.selection && document.selection.empty) {
|
|
|
725 document.selection.empty();
|
|
|
726 }
|
|
|
727 else {
|
|
|
728 if(window.getSelection) {
|
|
|
729 var sel = window.getSelection();
|
|
|
730 try {
|
|
|
731 sel.removeAllRanges();
|
|
|
732 sel.collapse();
|
|
|
733 } catch (ignore) { }
|
|
|
734 }
|
|
|
735 }
|
|
|
736 })
|
|
|
737 .on("mousedown.jstree", $.proxy(function (e) {
|
|
|
738 if(e.target === this.element[0]) {
|
|
|
739 e.preventDefault(); // prevent losing focus when clicking scroll arrows (FF, Chrome)
|
|
|
740 was_click = +(new Date()); // ie does not allow to prevent losing focus
|
|
|
741 }
|
|
|
742 }, this))
|
|
|
743 .on("mousedown.jstree", ".jstree-ocl", function (e) {
|
|
|
744 e.preventDefault(); // prevent any node inside from losing focus when clicking the open/close icon
|
|
|
745 })
|
|
|
746 .on("click.jstree", ".jstree-ocl", $.proxy(function (e) {
|
|
|
747 this.toggle_node(e.target);
|
|
|
748 }, this))
|
|
|
749 .on("dblclick.jstree", ".jstree-anchor", $.proxy(function (e) {
|
|
|
750 if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }
|
|
|
751 if(this.settings.core.dblclick_toggle) {
|
|
|
752 this.toggle_node(e.target);
|
|
|
753 }
|
|
|
754 }, this))
|
|
|
755 .on("click.jstree", ".jstree-anchor", $.proxy(function (e) {
|
|
|
756 e.preventDefault();
|
|
|
757 if(e.currentTarget !== document.activeElement) { $(e.currentTarget).focus(); }
|
|
|
758 this.activate_node(e.currentTarget, e);
|
|
|
759 }, this))
|
|
|
760 .on('keydown.jstree', '.jstree-anchor', $.proxy(function (e) {
|
|
|
761 if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }
|
|
|
762 if(this._data.core.rtl) {
|
|
|
763 if(e.which === 37) { e.which = 39; }
|
|
|
764 else if(e.which === 39) { e.which = 37; }
|
|
|
765 }
|
|
|
766 var f = this._kbevent_to_func(e);
|
|
|
767 if (f) {
|
|
|
768 var r = f.call(this, e);
|
|
|
769 if (r === false || r === true) {
|
|
|
770 return r;
|
|
|
771 }
|
|
|
772 }
|
|
|
773 }, this))
|
|
|
774 .on("load_node.jstree", $.proxy(function (e, data) {
|
|
|
775 if(data.status) {
|
|
|
776 if(data.node.id === $.jstree.root && !this._data.core.loaded) {
|
|
|
777 this._data.core.loaded = true;
|
|
|
778 if(this._firstChild(this.get_container_ul()[0])) {
|
|
|
779 this.element.attr('aria-activedescendant',this._firstChild(this.get_container_ul()[0]).id);
|
|
|
780 }
|
|
|
781 /**
|
|
|
782 * triggered after the root node is loaded for the first time
|
|
|
783 * @event
|
|
|
784 * @name loaded.jstree
|
|
|
785 */
|
|
|
786 this.trigger("loaded");
|
|
|
787 }
|
|
|
788 if(!this._data.core.ready) {
|
|
|
789 setTimeout($.proxy(function() {
|
|
|
790 if(this.element && !this.get_container_ul().find('.jstree-loading').length) {
|
|
|
791 this._data.core.ready = true;
|
|
|
792 if(this._data.core.selected.length) {
|
|
|
793 if(this.settings.core.expand_selected_onload) {
|
|
|
794 var tmp = [], i, j;
|
|
|
795 for(i = 0, j = this._data.core.selected.length; i < j; i++) {
|
|
|
796 tmp = tmp.concat(this._model.data[this._data.core.selected[i]].parents);
|
|
|
797 }
|
|
|
798 tmp = $.vakata.array_unique(tmp);
|
|
|
799 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
800 this.open_node(tmp[i], false, 0);
|
|
|
801 }
|
|
|
802 }
|
|
|
803 this.trigger('changed', { 'action' : 'ready', 'selected' : this._data.core.selected });
|
|
|
804 }
|
|
|
805 /**
|
|
|
806 * triggered after all nodes are finished loading
|
|
|
807 * @event
|
|
|
808 * @name ready.jstree
|
|
|
809 */
|
|
|
810 this.trigger("ready");
|
|
|
811 }
|
|
|
812 }, this), 0);
|
|
|
813 }
|
|
|
814 }
|
|
|
815 }, this))
|
|
|
816 // quick searching when the tree is focused
|
|
|
817 .on('keypress.jstree', $.proxy(function (e) {
|
|
|
818 if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }
|
|
|
819 if(tout) { clearTimeout(tout); }
|
|
|
820 tout = setTimeout(function () {
|
|
|
821 word = '';
|
|
|
822 }, 500);
|
|
|
823
|
|
|
824 var chr = String.fromCharCode(e.which).toLowerCase(),
|
|
|
825 col = this.element.find('.jstree-anchor').filter(':visible'),
|
|
|
826 ind = col.index(document.activeElement) || 0,
|
|
|
827 end = false;
|
|
|
828 word += chr;
|
|
|
829
|
|
|
830 // match for whole word from current node down (including the current node)
|
|
|
831 if(word.length > 1) {
|
|
|
832 col.slice(ind).each($.proxy(function (i, v) {
|
|
|
833 if($(v).text().toLowerCase().indexOf(word) === 0) {
|
|
|
834 $(v).focus();
|
|
|
835 end = true;
|
|
|
836 return false;
|
|
|
837 }
|
|
|
838 }, this));
|
|
|
839 if(end) { return; }
|
|
|
840
|
|
|
841 // match for whole word from the beginning of the tree
|
|
|
842 col.slice(0, ind).each($.proxy(function (i, v) {
|
|
|
843 if($(v).text().toLowerCase().indexOf(word) === 0) {
|
|
|
844 $(v).focus();
|
|
|
845 end = true;
|
|
|
846 return false;
|
|
|
847 }
|
|
|
848 }, this));
|
|
|
849 if(end) { return; }
|
|
|
850 }
|
|
|
851 // list nodes that start with that letter (only if word consists of a single char)
|
|
|
852 if(new RegExp('^' + chr.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + '+$').test(word)) {
|
|
|
853 // search for the next node starting with that letter
|
|
|
854 col.slice(ind + 1).each($.proxy(function (i, v) {
|
|
|
855 if($(v).text().toLowerCase().charAt(0) === chr) {
|
|
|
856 $(v).focus();
|
|
|
857 end = true;
|
|
|
858 return false;
|
|
|
859 }
|
|
|
860 }, this));
|
|
|
861 if(end) { return; }
|
|
|
862
|
|
|
863 // search from the beginning
|
|
|
864 col.slice(0, ind + 1).each($.proxy(function (i, v) {
|
|
|
865 if($(v).text().toLowerCase().charAt(0) === chr) {
|
|
|
866 $(v).focus();
|
|
|
867 end = true;
|
|
|
868 return false;
|
|
|
869 }
|
|
|
870 }, this));
|
|
|
871 if(end) { return; }
|
|
|
872 }
|
|
|
873 }, this))
|
|
|
874 // THEME RELATED
|
|
|
875 .on("init.jstree", $.proxy(function () {
|
|
|
876 var s = this.settings.core.themes;
|
|
|
877 this._data.core.themes.dots = s.dots;
|
|
|
878 this._data.core.themes.stripes = s.stripes;
|
|
|
879 this._data.core.themes.icons = s.icons;
|
|
|
880 this._data.core.themes.ellipsis = s.ellipsis;
|
|
|
881 this.set_theme(s.name || "default", s.url);
|
|
|
882 this.set_theme_variant(s.variant);
|
|
|
883 }, this))
|
|
|
884 .on("loading.jstree", $.proxy(function () {
|
|
|
885 this[ this._data.core.themes.dots ? "show_dots" : "hide_dots" ]();
|
|
|
886 this[ this._data.core.themes.icons ? "show_icons" : "hide_icons" ]();
|
|
|
887 this[ this._data.core.themes.stripes ? "show_stripes" : "hide_stripes" ]();
|
|
|
888 this[ this._data.core.themes.ellipsis ? "show_ellipsis" : "hide_ellipsis" ]();
|
|
|
889 }, this))
|
|
|
890 .on('blur.jstree', '.jstree-anchor', $.proxy(function (e) {
|
|
|
891 this._data.core.focused = null;
|
|
|
892 $(e.currentTarget).filter('.jstree-hovered').mouseleave();
|
|
|
893 this.element.attr('tabindex', '0');
|
|
|
894 }, this))
|
|
|
895 .on('focus.jstree', '.jstree-anchor', $.proxy(function (e) {
|
|
|
896 var tmp = this.get_node(e.currentTarget);
|
|
|
897 if(tmp && tmp.id) {
|
|
|
898 this._data.core.focused = tmp.id;
|
|
|
899 }
|
|
|
900 this.element.find('.jstree-hovered').not(e.currentTarget).mouseleave();
|
|
|
901 $(e.currentTarget).mouseenter();
|
|
|
902 this.element.attr('tabindex', '-1');
|
|
|
903 }, this))
|
|
|
904 .on('focus.jstree', $.proxy(function () {
|
|
|
905 if(+(new Date()) - was_click > 500 && !this._data.core.focused && this.settings.core.restore_focus) {
|
|
|
906 was_click = 0;
|
|
|
907 var act = this.get_node(this.element.attr('aria-activedescendant'), true);
|
|
|
908 if(act) {
|
|
|
909 act.find('> .jstree-anchor').focus();
|
|
|
910 }
|
|
|
911 }
|
|
|
912 }, this))
|
|
|
913 .on('mouseenter.jstree', '.jstree-anchor', $.proxy(function (e) {
|
|
|
914 this.hover_node(e.currentTarget);
|
|
|
915 }, this))
|
|
|
916 .on('mouseleave.jstree', '.jstree-anchor', $.proxy(function (e) {
|
|
|
917 this.dehover_node(e.currentTarget);
|
|
|
918 }, this));
|
|
|
919 },
|
|
|
920 /**
|
|
|
921 * part of the destroying of an instance. Used internally.
|
|
|
922 * @private
|
|
|
923 * @name unbind()
|
|
|
924 */
|
|
|
925 unbind : function () {
|
|
|
926 this.element.off('.jstree');
|
|
|
927 $(document).off('.jstree-' + this._id);
|
|
|
928 },
|
|
|
929 /**
|
|
|
930 * trigger an event. Used internally.
|
|
|
931 * @private
|
|
|
932 * @name trigger(ev [, data])
|
|
|
933 * @param {String} ev the name of the event to trigger
|
|
|
934 * @param {Object} data additional data to pass with the event
|
|
|
935 */
|
|
|
936 trigger : function (ev, data) {
|
|
|
937 if(!data) {
|
|
|
938 data = {};
|
|
|
939 }
|
|
|
940 data.instance = this;
|
|
|
941 this.element.triggerHandler(ev.replace('.jstree','') + '.jstree', data);
|
|
|
942 },
|
|
|
943 /**
|
|
|
944 * returns the jQuery extended instance container
|
|
|
945 * @name get_container()
|
|
|
946 * @return {jQuery}
|
|
|
947 */
|
|
|
948 get_container : function () {
|
|
|
949 return this.element;
|
|
|
950 },
|
|
|
951 /**
|
|
|
952 * returns the jQuery extended main UL node inside the instance container. Used internally.
|
|
|
953 * @private
|
|
|
954 * @name get_container_ul()
|
|
|
955 * @return {jQuery}
|
|
|
956 */
|
|
|
957 get_container_ul : function () {
|
|
|
958 return this.element.children(".jstree-children").first();
|
|
|
959 },
|
|
|
960 /**
|
|
|
961 * gets string replacements (localization). Used internally.
|
|
|
962 * @private
|
|
|
963 * @name get_string(key)
|
|
|
964 * @param {String} key
|
|
|
965 * @return {String}
|
|
|
966 */
|
|
|
967 get_string : function (key) {
|
|
|
968 var a = this.settings.core.strings;
|
|
|
969 if($.isFunction(a)) { return a.call(this, key); }
|
|
|
970 if(a && a[key]) { return a[key]; }
|
|
|
971 return key;
|
|
|
972 },
|
|
|
973 /**
|
|
|
974 * gets the first child of a DOM node. Used internally.
|
|
|
975 * @private
|
|
|
976 * @name _firstChild(dom)
|
|
|
977 * @param {DOMElement} dom
|
|
|
978 * @return {DOMElement}
|
|
|
979 */
|
|
|
980 _firstChild : function (dom) {
|
|
|
981 dom = dom ? dom.firstChild : null;
|
|
|
982 while(dom !== null && dom.nodeType !== 1) {
|
|
|
983 dom = dom.nextSibling;
|
|
|
984 }
|
|
|
985 return dom;
|
|
|
986 },
|
|
|
987 /**
|
|
|
988 * gets the next sibling of a DOM node. Used internally.
|
|
|
989 * @private
|
|
|
990 * @name _nextSibling(dom)
|
|
|
991 * @param {DOMElement} dom
|
|
|
992 * @return {DOMElement}
|
|
|
993 */
|
|
|
994 _nextSibling : function (dom) {
|
|
|
995 dom = dom ? dom.nextSibling : null;
|
|
|
996 while(dom !== null && dom.nodeType !== 1) {
|
|
|
997 dom = dom.nextSibling;
|
|
|
998 }
|
|
|
999 return dom;
|
|
|
1000 },
|
|
|
1001 /**
|
|
|
1002 * gets the previous sibling of a DOM node. Used internally.
|
|
|
1003 * @private
|
|
|
1004 * @name _previousSibling(dom)
|
|
|
1005 * @param {DOMElement} dom
|
|
|
1006 * @return {DOMElement}
|
|
|
1007 */
|
|
|
1008 _previousSibling : function (dom) {
|
|
|
1009 dom = dom ? dom.previousSibling : null;
|
|
|
1010 while(dom !== null && dom.nodeType !== 1) {
|
|
|
1011 dom = dom.previousSibling;
|
|
|
1012 }
|
|
|
1013 return dom;
|
|
|
1014 },
|
|
|
1015 /**
|
|
|
1016 * get the JSON representation of a node (or the actual jQuery extended DOM node) by using any input (child DOM element, ID string, selector, etc)
|
|
|
1017 * @name get_node(obj [, as_dom])
|
|
|
1018 * @param {mixed} obj
|
|
|
1019 * @param {Boolean} as_dom
|
|
|
1020 * @return {Object|jQuery}
|
|
|
1021 */
|
|
|
1022 get_node : function (obj, as_dom) {
|
|
|
1023 if(obj && obj.id) {
|
|
|
1024 obj = obj.id;
|
|
|
1025 }
|
|
|
1026 var dom;
|
|
|
1027 try {
|
|
|
1028 if(this._model.data[obj]) {
|
|
|
1029 obj = this._model.data[obj];
|
|
|
1030 }
|
|
|
1031 else if(typeof obj === "string" && this._model.data[obj.replace(/^#/, '')]) {
|
|
|
1032 obj = this._model.data[obj.replace(/^#/, '')];
|
|
|
1033 }
|
|
|
1034 else if(typeof obj === "string" && (dom = $('#' + obj.replace($.jstree.idregex,'\\$&'), this.element)).length && this._model.data[dom.closest('.jstree-node').attr('id')]) {
|
|
|
1035 obj = this._model.data[dom.closest('.jstree-node').attr('id')];
|
|
|
1036 }
|
|
|
1037 else if((dom = $(obj, this.element)).length && this._model.data[dom.closest('.jstree-node').attr('id')]) {
|
|
|
1038 obj = this._model.data[dom.closest('.jstree-node').attr('id')];
|
|
|
1039 }
|
|
|
1040 else if((dom = $(obj, this.element)).length && dom.hasClass('jstree')) {
|
|
|
1041 obj = this._model.data[$.jstree.root];
|
|
|
1042 }
|
|
|
1043 else {
|
|
|
1044 return false;
|
|
|
1045 }
|
|
|
1046
|
|
|
1047 if(as_dom) {
|
|
|
1048 obj = obj.id === $.jstree.root ? this.element : $('#' + obj.id.replace($.jstree.idregex,'\\$&'), this.element);
|
|
|
1049 }
|
|
|
1050 return obj;
|
|
|
1051 } catch (ex) { return false; }
|
|
|
1052 },
|
|
|
1053 /**
|
|
|
1054 * get the path to a node, either consisting of node texts, or of node IDs, optionally glued together (otherwise an array)
|
|
|
1055 * @name get_path(obj [, glue, ids])
|
|
|
1056 * @param {mixed} obj the node
|
|
|
1057 * @param {String} glue if you want the path as a string - pass the glue here (for example '/'), if a falsy value is supplied here, an array is returned
|
|
|
1058 * @param {Boolean} ids if set to true build the path using ID, otherwise node text is used
|
|
|
1059 * @return {mixed}
|
|
|
1060 */
|
|
|
1061 get_path : function (obj, glue, ids) {
|
|
|
1062 obj = obj.parents ? obj : this.get_node(obj);
|
|
|
1063 if(!obj || obj.id === $.jstree.root || !obj.parents) {
|
|
|
1064 return false;
|
|
|
1065 }
|
|
|
1066 var i, j, p = [];
|
|
|
1067 p.push(ids ? obj.id : obj.text);
|
|
|
1068 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
1069 p.push(ids ? obj.parents[i] : this.get_text(obj.parents[i]));
|
|
|
1070 }
|
|
|
1071 p = p.reverse().slice(1);
|
|
|
1072 return glue ? p.join(glue) : p;
|
|
|
1073 },
|
|
|
1074 /**
|
|
|
1075 * get the next visible node that is below the `obj` node. If `strict` is set to `true` only sibling nodes are returned.
|
|
|
1076 * @name get_next_dom(obj [, strict])
|
|
|
1077 * @param {mixed} obj
|
|
|
1078 * @param {Boolean} strict
|
|
|
1079 * @return {jQuery}
|
|
|
1080 */
|
|
|
1081 get_next_dom : function (obj, strict) {
|
|
|
1082 var tmp;
|
|
|
1083 obj = this.get_node(obj, true);
|
|
|
1084 if(obj[0] === this.element[0]) {
|
|
|
1085 tmp = this._firstChild(this.get_container_ul()[0]);
|
|
|
1086 while (tmp && tmp.offsetHeight === 0) {
|
|
|
1087 tmp = this._nextSibling(tmp);
|
|
|
1088 }
|
|
|
1089 return tmp ? $(tmp) : false;
|
|
|
1090 }
|
|
|
1091 if(!obj || !obj.length) {
|
|
|
1092 return false;
|
|
|
1093 }
|
|
|
1094 if(strict) {
|
|
|
1095 tmp = obj[0];
|
|
|
1096 do {
|
|
|
1097 tmp = this._nextSibling(tmp);
|
|
|
1098 } while (tmp && tmp.offsetHeight === 0);
|
|
|
1099 return tmp ? $(tmp) : false;
|
|
|
1100 }
|
|
|
1101 if(obj.hasClass("jstree-open")) {
|
|
|
1102 tmp = this._firstChild(obj.children('.jstree-children')[0]);
|
|
|
1103 while (tmp && tmp.offsetHeight === 0) {
|
|
|
1104 tmp = this._nextSibling(tmp);
|
|
|
1105 }
|
|
|
1106 if(tmp !== null) {
|
|
|
1107 return $(tmp);
|
|
|
1108 }
|
|
|
1109 }
|
|
|
1110 tmp = obj[0];
|
|
|
1111 do {
|
|
|
1112 tmp = this._nextSibling(tmp);
|
|
|
1113 } while (tmp && tmp.offsetHeight === 0);
|
|
|
1114 if(tmp !== null) {
|
|
|
1115 return $(tmp);
|
|
|
1116 }
|
|
|
1117 return obj.parentsUntil(".jstree",".jstree-node").nextAll(".jstree-node:visible").first();
|
|
|
1118 },
|
|
|
1119 /**
|
|
|
1120 * get the previous visible node that is above the `obj` node. If `strict` is set to `true` only sibling nodes are returned.
|
|
|
1121 * @name get_prev_dom(obj [, strict])
|
|
|
1122 * @param {mixed} obj
|
|
|
1123 * @param {Boolean} strict
|
|
|
1124 * @return {jQuery}
|
|
|
1125 */
|
|
|
1126 get_prev_dom : function (obj, strict) {
|
|
|
1127 var tmp;
|
|
|
1128 obj = this.get_node(obj, true);
|
|
|
1129 if(obj[0] === this.element[0]) {
|
|
|
1130 tmp = this.get_container_ul()[0].lastChild;
|
|
|
1131 while (tmp && tmp.offsetHeight === 0) {
|
|
|
1132 tmp = this._previousSibling(tmp);
|
|
|
1133 }
|
|
|
1134 return tmp ? $(tmp) : false;
|
|
|
1135 }
|
|
|
1136 if(!obj || !obj.length) {
|
|
|
1137 return false;
|
|
|
1138 }
|
|
|
1139 if(strict) {
|
|
|
1140 tmp = obj[0];
|
|
|
1141 do {
|
|
|
1142 tmp = this._previousSibling(tmp);
|
|
|
1143 } while (tmp && tmp.offsetHeight === 0);
|
|
|
1144 return tmp ? $(tmp) : false;
|
|
|
1145 }
|
|
|
1146 tmp = obj[0];
|
|
|
1147 do {
|
|
|
1148 tmp = this._previousSibling(tmp);
|
|
|
1149 } while (tmp && tmp.offsetHeight === 0);
|
|
|
1150 if(tmp !== null) {
|
|
|
1151 obj = $(tmp);
|
|
|
1152 while(obj.hasClass("jstree-open")) {
|
|
|
1153 obj = obj.children(".jstree-children").first().children(".jstree-node:visible:last");
|
|
|
1154 }
|
|
|
1155 return obj;
|
|
|
1156 }
|
|
|
1157 tmp = obj[0].parentNode.parentNode;
|
|
|
1158 return tmp && tmp.className && tmp.className.indexOf('jstree-node') !== -1 ? $(tmp) : false;
|
|
|
1159 },
|
|
|
1160 /**
|
|
|
1161 * get the parent ID of a node
|
|
|
1162 * @name get_parent(obj)
|
|
|
1163 * @param {mixed} obj
|
|
|
1164 * @return {String}
|
|
|
1165 */
|
|
|
1166 get_parent : function (obj) {
|
|
|
1167 obj = this.get_node(obj);
|
|
|
1168 if(!obj || obj.id === $.jstree.root) {
|
|
|
1169 return false;
|
|
|
1170 }
|
|
|
1171 return obj.parent;
|
|
|
1172 },
|
|
|
1173 /**
|
|
|
1174 * get a jQuery collection of all the children of a node (node must be rendered), returns false on error
|
|
|
1175 * @name get_children_dom(obj)
|
|
|
1176 * @param {mixed} obj
|
|
|
1177 * @return {jQuery}
|
|
|
1178 */
|
|
|
1179 get_children_dom : function (obj) {
|
|
|
1180 obj = this.get_node(obj, true);
|
|
|
1181 if(obj[0] === this.element[0]) {
|
|
|
1182 return this.get_container_ul().children(".jstree-node");
|
|
|
1183 }
|
|
|
1184 if(!obj || !obj.length) {
|
|
|
1185 return false;
|
|
|
1186 }
|
|
|
1187 return obj.children(".jstree-children").children(".jstree-node");
|
|
|
1188 },
|
|
|
1189 /**
|
|
|
1190 * checks if a node has children
|
|
|
1191 * @name is_parent(obj)
|
|
|
1192 * @param {mixed} obj
|
|
|
1193 * @return {Boolean}
|
|
|
1194 */
|
|
|
1195 is_parent : function (obj) {
|
|
|
1196 obj = this.get_node(obj);
|
|
|
1197 return obj && (obj.state.loaded === false || obj.children.length > 0);
|
|
|
1198 },
|
|
|
1199 /**
|
|
|
1200 * checks if a node is loaded (its children are available)
|
|
|
1201 * @name is_loaded(obj)
|
|
|
1202 * @param {mixed} obj
|
|
|
1203 * @return {Boolean}
|
|
|
1204 */
|
|
|
1205 is_loaded : function (obj) {
|
|
|
1206 obj = this.get_node(obj);
|
|
|
1207 return obj && obj.state.loaded;
|
|
|
1208 },
|
|
|
1209 /**
|
|
|
1210 * check if a node is currently loading (fetching children)
|
|
|
1211 * @name is_loading(obj)
|
|
|
1212 * @param {mixed} obj
|
|
|
1213 * @return {Boolean}
|
|
|
1214 */
|
|
|
1215 is_loading : function (obj) {
|
|
|
1216 obj = this.get_node(obj);
|
|
|
1217 return obj && obj.state && obj.state.loading;
|
|
|
1218 },
|
|
|
1219 /**
|
|
|
1220 * check if a node is opened
|
|
|
1221 * @name is_open(obj)
|
|
|
1222 * @param {mixed} obj
|
|
|
1223 * @return {Boolean}
|
|
|
1224 */
|
|
|
1225 is_open : function (obj) {
|
|
|
1226 obj = this.get_node(obj);
|
|
|
1227 return obj && obj.state.opened;
|
|
|
1228 },
|
|
|
1229 /**
|
|
|
1230 * check if a node is in a closed state
|
|
|
1231 * @name is_closed(obj)
|
|
|
1232 * @param {mixed} obj
|
|
|
1233 * @return {Boolean}
|
|
|
1234 */
|
|
|
1235 is_closed : function (obj) {
|
|
|
1236 obj = this.get_node(obj);
|
|
|
1237 return obj && this.is_parent(obj) && !obj.state.opened;
|
|
|
1238 },
|
|
|
1239 /**
|
|
|
1240 * check if a node has no children
|
|
|
1241 * @name is_leaf(obj)
|
|
|
1242 * @param {mixed} obj
|
|
|
1243 * @return {Boolean}
|
|
|
1244 */
|
|
|
1245 is_leaf : function (obj) {
|
|
|
1246 return !this.is_parent(obj);
|
|
|
1247 },
|
|
|
1248 /**
|
|
|
1249 * loads a node (fetches its children using the `core.data` setting). Multiple nodes can be passed to by using an array.
|
|
|
1250 * @name load_node(obj [, callback])
|
|
|
1251 * @param {mixed} obj
|
|
|
1252 * @param {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives two arguments - the node and a boolean status
|
|
|
1253 * @return {Boolean}
|
|
|
1254 * @trigger load_node.jstree
|
|
|
1255 */
|
|
|
1256 load_node : function (obj, callback) {
|
|
|
1257 var k, l, i, j, c;
|
|
|
1258 if($.isArray(obj)) {
|
|
|
1259 this._load_nodes(obj.slice(), callback);
|
|
|
1260 return true;
|
|
|
1261 }
|
|
|
1262 obj = this.get_node(obj);
|
|
|
1263 if(!obj) {
|
|
|
1264 if(callback) { callback.call(this, obj, false); }
|
|
|
1265 return false;
|
|
|
1266 }
|
|
|
1267 // if(obj.state.loading) { } // the node is already loading - just wait for it to load and invoke callback? but if called implicitly it should be loaded again?
|
|
|
1268 if(obj.state.loaded) {
|
|
|
1269 obj.state.loaded = false;
|
|
|
1270 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
1271 this._model.data[obj.parents[i]].children_d = $.vakata.array_filter(this._model.data[obj.parents[i]].children_d, function (v) {
|
|
|
1272 return $.inArray(v, obj.children_d) === -1;
|
|
|
1273 });
|
|
|
1274 }
|
|
|
1275 for(k = 0, l = obj.children_d.length; k < l; k++) {
|
|
|
1276 if(this._model.data[obj.children_d[k]].state.selected) {
|
|
|
1277 c = true;
|
|
|
1278 }
|
|
|
1279 delete this._model.data[obj.children_d[k]];
|
|
|
1280 }
|
|
|
1281 if (c) {
|
|
|
1282 this._data.core.selected = $.vakata.array_filter(this._data.core.selected, function (v) {
|
|
|
1283 return $.inArray(v, obj.children_d) === -1;
|
|
|
1284 });
|
|
|
1285 }
|
|
|
1286 obj.children = [];
|
|
|
1287 obj.children_d = [];
|
|
|
1288 if(c) {
|
|
|
1289 this.trigger('changed', { 'action' : 'load_node', 'node' : obj, 'selected' : this._data.core.selected });
|
|
|
1290 }
|
|
|
1291 }
|
|
|
1292 obj.state.failed = false;
|
|
|
1293 obj.state.loading = true;
|
|
|
1294 this.get_node(obj, true).addClass("jstree-loading").attr('aria-busy',true);
|
|
|
1295 this._load_node(obj, $.proxy(function (status) {
|
|
|
1296 obj = this._model.data[obj.id];
|
|
|
1297 obj.state.loading = false;
|
|
|
1298 obj.state.loaded = status;
|
|
|
1299 obj.state.failed = !obj.state.loaded;
|
|
|
1300 var dom = this.get_node(obj, true), i = 0, j = 0, m = this._model.data, has_children = false;
|
|
|
1301 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
1302 if(m[obj.children[i]] && !m[obj.children[i]].state.hidden) {
|
|
|
1303 has_children = true;
|
|
|
1304 break;
|
|
|
1305 }
|
|
|
1306 }
|
|
|
1307 if(obj.state.loaded && dom && dom.length) {
|
|
|
1308 dom.removeClass('jstree-closed jstree-open jstree-leaf');
|
|
|
1309 if (!has_children) {
|
|
|
1310 dom.addClass('jstree-leaf');
|
|
|
1311 }
|
|
|
1312 else {
|
|
|
1313 if (obj.id !== '#') {
|
|
|
1314 dom.addClass(obj.state.opened ? 'jstree-open' : 'jstree-closed');
|
|
|
1315 }
|
|
|
1316 }
|
|
|
1317 }
|
|
|
1318 dom.removeClass("jstree-loading").attr('aria-busy',false);
|
|
|
1319 /**
|
|
|
1320 * triggered after a node is loaded
|
|
|
1321 * @event
|
|
|
1322 * @name load_node.jstree
|
|
|
1323 * @param {Object} node the node that was loading
|
|
|
1324 * @param {Boolean} status was the node loaded successfully
|
|
|
1325 */
|
|
|
1326 this.trigger('load_node', { "node" : obj, "status" : status });
|
|
|
1327 if(callback) {
|
|
|
1328 callback.call(this, obj, status);
|
|
|
1329 }
|
|
|
1330 }, this));
|
|
|
1331 return true;
|
|
|
1332 },
|
|
|
1333 /**
|
|
|
1334 * load an array of nodes (will also load unavailable nodes as soon as the appear in the structure). Used internally.
|
|
|
1335 * @private
|
|
|
1336 * @name _load_nodes(nodes [, callback])
|
|
|
1337 * @param {array} nodes
|
|
|
1338 * @param {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives one argument - the array passed to _load_nodes
|
|
|
1339 */
|
|
|
1340 _load_nodes : function (nodes, callback, is_callback, force_reload) {
|
|
|
1341 var r = true,
|
|
|
1342 c = function () { this._load_nodes(nodes, callback, true); },
|
|
|
1343 m = this._model.data, i, j, tmp = [];
|
|
|
1344 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
1345 if(m[nodes[i]] && ( (!m[nodes[i]].state.loaded && !m[nodes[i]].state.failed) || (!is_callback && force_reload) )) {
|
|
|
1346 if(!this.is_loading(nodes[i])) {
|
|
|
1347 this.load_node(nodes[i], c);
|
|
|
1348 }
|
|
|
1349 r = false;
|
|
|
1350 }
|
|
|
1351 }
|
|
|
1352 if(r) {
|
|
|
1353 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
1354 if(m[nodes[i]] && m[nodes[i]].state.loaded) {
|
|
|
1355 tmp.push(nodes[i]);
|
|
|
1356 }
|
|
|
1357 }
|
|
|
1358 if(callback && !callback.done) {
|
|
|
1359 callback.call(this, tmp);
|
|
|
1360 callback.done = true;
|
|
|
1361 }
|
|
|
1362 }
|
|
|
1363 },
|
|
|
1364 /**
|
|
|
1365 * loads all unloaded nodes
|
|
|
1366 * @name load_all([obj, callback])
|
|
|
1367 * @param {mixed} obj the node to load recursively, omit to load all nodes in the tree
|
|
|
1368 * @param {function} callback a function to be executed once loading all the nodes is complete,
|
|
|
1369 * @trigger load_all.jstree
|
|
|
1370 */
|
|
|
1371 load_all : function (obj, callback) {
|
|
|
1372 if(!obj) { obj = $.jstree.root; }
|
|
|
1373 obj = this.get_node(obj);
|
|
|
1374 if(!obj) { return false; }
|
|
|
1375 var to_load = [],
|
|
|
1376 m = this._model.data,
|
|
|
1377 c = m[obj.id].children_d,
|
|
|
1378 i, j;
|
|
|
1379 if(obj.state && !obj.state.loaded) {
|
|
|
1380 to_load.push(obj.id);
|
|
|
1381 }
|
|
|
1382 for(i = 0, j = c.length; i < j; i++) {
|
|
|
1383 if(m[c[i]] && m[c[i]].state && !m[c[i]].state.loaded) {
|
|
|
1384 to_load.push(c[i]);
|
|
|
1385 }
|
|
|
1386 }
|
|
|
1387 if(to_load.length) {
|
|
|
1388 this._load_nodes(to_load, function () {
|
|
|
1389 this.load_all(obj, callback);
|
|
|
1390 });
|
|
|
1391 }
|
|
|
1392 else {
|
|
|
1393 /**
|
|
|
1394 * triggered after a load_all call completes
|
|
|
1395 * @event
|
|
|
1396 * @name load_all.jstree
|
|
|
1397 * @param {Object} node the recursively loaded node
|
|
|
1398 */
|
|
|
1399 if(callback) { callback.call(this, obj); }
|
|
|
1400 this.trigger('load_all', { "node" : obj });
|
|
|
1401 }
|
|
|
1402 },
|
|
|
1403 /**
|
|
|
1404 * handles the actual loading of a node. Used only internally.
|
|
|
1405 * @private
|
|
|
1406 * @name _load_node(obj [, callback])
|
|
|
1407 * @param {mixed} obj
|
|
|
1408 * @param {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives one argument - a boolean status
|
|
|
1409 * @return {Boolean}
|
|
|
1410 */
|
|
|
1411 _load_node : function (obj, callback) {
|
|
|
1412 var s = this.settings.core.data, t;
|
|
|
1413 var notTextOrCommentNode = function notTextOrCommentNode () {
|
|
|
1414 return this.nodeType !== 3 && this.nodeType !== 8;
|
|
|
1415 };
|
|
|
1416 // use original HTML
|
|
|
1417 if(!s) {
|
|
|
1418 if(obj.id === $.jstree.root) {
|
|
|
1419 return this._append_html_data(obj, this._data.core.original_container_html.clone(true), function (status) {
|
|
|
1420 callback.call(this, status);
|
|
|
1421 });
|
|
|
1422 }
|
|
|
1423 else {
|
|
|
1424 return callback.call(this, false);
|
|
|
1425 }
|
|
|
1426 // return callback.call(this, obj.id === $.jstree.root ? this._append_html_data(obj, this._data.core.original_container_html.clone(true)) : false);
|
|
|
1427 }
|
|
|
1428 if($.isFunction(s)) {
|
|
|
1429 return s.call(this, obj, $.proxy(function (d) {
|
|
|
1430 if(d === false) {
|
|
|
1431 callback.call(this, false);
|
|
|
1432 }
|
|
|
1433 else {
|
|
|
1434 this[typeof d === 'string' ? '_append_html_data' : '_append_json_data'](obj, typeof d === 'string' ? $($.parseHTML(d)).filter(notTextOrCommentNode) : d, function (status) {
|
|
|
1435 callback.call(this, status);
|
|
|
1436 });
|
|
|
1437 }
|
|
|
1438 // return d === false ? callback.call(this, false) : callback.call(this, this[typeof d === 'string' ? '_append_html_data' : '_append_json_data'](obj, typeof d === 'string' ? $(d) : d));
|
|
|
1439 }, this));
|
|
|
1440 }
|
|
|
1441 if(typeof s === 'object') {
|
|
|
1442 if(s.url) {
|
|
|
1443 s = $.extend(true, {}, s);
|
|
|
1444 if($.isFunction(s.url)) {
|
|
|
1445 s.url = s.url.call(this, obj);
|
|
|
1446 }
|
|
|
1447 if($.isFunction(s.data)) {
|
|
|
1448 s.data = s.data.call(this, obj);
|
|
|
1449 }
|
|
|
1450 return $.ajax(s)
|
|
|
1451 .done($.proxy(function (d,t,x) {
|
|
|
1452 var type = x.getResponseHeader('Content-Type');
|
|
|
1453 if((type && type.indexOf('json') !== -1) || typeof d === "object") {
|
|
|
1454 return this._append_json_data(obj, d, function (status) { callback.call(this, status); });
|
|
|
1455 //return callback.call(this, this._append_json_data(obj, d));
|
|
|
1456 }
|
|
|
1457 if((type && type.indexOf('html') !== -1) || typeof d === "string") {
|
|
|
1458 return this._append_html_data(obj, $($.parseHTML(d)).filter(notTextOrCommentNode), function (status) { callback.call(this, status); });
|
|
|
1459 // return callback.call(this, this._append_html_data(obj, $(d)));
|
|
|
1460 }
|
|
|
1461 this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'core', 'id' : 'core_04', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id, 'xhr' : x }) };
|
|
|
1462 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
1463 return callback.call(this, false);
|
|
|
1464 }, this))
|
|
|
1465 .fail($.proxy(function (f) {
|
|
|
1466 this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'core', 'id' : 'core_04', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id, 'xhr' : f }) };
|
|
|
1467 callback.call(this, false);
|
|
|
1468 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
1469 }, this));
|
|
|
1470 }
|
|
|
1471 if ($.isArray(s)) {
|
|
|
1472 t = $.extend(true, [], s);
|
|
|
1473 } else if ($.isPlainObject(s)) {
|
|
|
1474 t = $.extend(true, {}, s);
|
|
|
1475 } else {
|
|
|
1476 t = s;
|
|
|
1477 }
|
|
|
1478 if(obj.id === $.jstree.root) {
|
|
|
1479 return this._append_json_data(obj, t, function (status) {
|
|
|
1480 callback.call(this, status);
|
|
|
1481 });
|
|
|
1482 }
|
|
|
1483 else {
|
|
|
1484 this._data.core.last_error = { 'error' : 'nodata', 'plugin' : 'core', 'id' : 'core_05', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id }) };
|
|
|
1485 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
1486 return callback.call(this, false);
|
|
|
1487 }
|
|
|
1488 //return callback.call(this, (obj.id === $.jstree.root ? this._append_json_data(obj, t) : false) );
|
|
|
1489 }
|
|
|
1490 if(typeof s === 'string') {
|
|
|
1491 if(obj.id === $.jstree.root) {
|
|
|
1492 return this._append_html_data(obj, $($.parseHTML(s)).filter(notTextOrCommentNode), function (status) {
|
|
|
1493 callback.call(this, status);
|
|
|
1494 });
|
|
|
1495 }
|
|
|
1496 else {
|
|
|
1497 this._data.core.last_error = { 'error' : 'nodata', 'plugin' : 'core', 'id' : 'core_06', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id }) };
|
|
|
1498 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
1499 return callback.call(this, false);
|
|
|
1500 }
|
|
|
1501 //return callback.call(this, (obj.id === $.jstree.root ? this._append_html_data(obj, $(s)) : false) );
|
|
|
1502 }
|
|
|
1503 return callback.call(this, false);
|
|
|
1504 },
|
|
|
1505 /**
|
|
|
1506 * adds a node to the list of nodes to redraw. Used only internally.
|
|
|
1507 * @private
|
|
|
1508 * @name _node_changed(obj [, callback])
|
|
|
1509 * @param {mixed} obj
|
|
|
1510 */
|
|
|
1511 _node_changed : function (obj) {
|
|
|
1512 obj = this.get_node(obj);
|
|
|
1513 if (obj && $.inArray(obj.id, this._model.changed) === -1) {
|
|
|
1514 this._model.changed.push(obj.id);
|
|
|
1515 }
|
|
|
1516 },
|
|
|
1517 /**
|
|
|
1518 * appends HTML content to the tree. Used internally.
|
|
|
1519 * @private
|
|
|
1520 * @name _append_html_data(obj, data)
|
|
|
1521 * @param {mixed} obj the node to append to
|
|
|
1522 * @param {String} data the HTML string to parse and append
|
|
|
1523 * @trigger model.jstree, changed.jstree
|
|
|
1524 */
|
|
|
1525 _append_html_data : function (dom, data, cb) {
|
|
|
1526 dom = this.get_node(dom);
|
|
|
1527 dom.children = [];
|
|
|
1528 dom.children_d = [];
|
|
|
1529 var dat = data.is('ul') ? data.children() : data,
|
|
|
1530 par = dom.id,
|
|
|
1531 chd = [],
|
|
|
1532 dpc = [],
|
|
|
1533 m = this._model.data,
|
|
|
1534 p = m[par],
|
|
|
1535 s = this._data.core.selected.length,
|
|
|
1536 tmp, i, j;
|
|
|
1537 dat.each($.proxy(function (i, v) {
|
|
|
1538 tmp = this._parse_model_from_html($(v), par, p.parents.concat());
|
|
|
1539 if(tmp) {
|
|
|
1540 chd.push(tmp);
|
|
|
1541 dpc.push(tmp);
|
|
|
1542 if(m[tmp].children_d.length) {
|
|
|
1543 dpc = dpc.concat(m[tmp].children_d);
|
|
|
1544 }
|
|
|
1545 }
|
|
|
1546 }, this));
|
|
|
1547 p.children = chd;
|
|
|
1548 p.children_d = dpc;
|
|
|
1549 for(i = 0, j = p.parents.length; i < j; i++) {
|
|
|
1550 m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);
|
|
|
1551 }
|
|
|
1552 /**
|
|
|
1553 * triggered when new data is inserted to the tree model
|
|
|
1554 * @event
|
|
|
1555 * @name model.jstree
|
|
|
1556 * @param {Array} nodes an array of node IDs
|
|
|
1557 * @param {String} parent the parent ID of the nodes
|
|
|
1558 */
|
|
|
1559 this.trigger('model', { "nodes" : dpc, 'parent' : par });
|
|
|
1560 if(par !== $.jstree.root) {
|
|
|
1561 this._node_changed(par);
|
|
|
1562 this.redraw();
|
|
|
1563 }
|
|
|
1564 else {
|
|
|
1565 this.get_container_ul().children('.jstree-initial-node').remove();
|
|
|
1566 this.redraw(true);
|
|
|
1567 }
|
|
|
1568 if(this._data.core.selected.length !== s) {
|
|
|
1569 this.trigger('changed', { 'action' : 'model', 'selected' : this._data.core.selected });
|
|
|
1570 }
|
|
|
1571 cb.call(this, true);
|
|
|
1572 },
|
|
|
1573 /**
|
|
|
1574 * appends JSON content to the tree. Used internally.
|
|
|
1575 * @private
|
|
|
1576 * @name _append_json_data(obj, data)
|
|
|
1577 * @param {mixed} obj the node to append to
|
|
|
1578 * @param {String} data the JSON object to parse and append
|
|
|
1579 * @param {Boolean} force_processing internal param - do not set
|
|
|
1580 * @trigger model.jstree, changed.jstree
|
|
|
1581 */
|
|
|
1582 _append_json_data : function (dom, data, cb, force_processing) {
|
|
|
1583 if(this.element === null) { return; }
|
|
|
1584 dom = this.get_node(dom);
|
|
|
1585 dom.children = [];
|
|
|
1586 dom.children_d = [];
|
|
|
1587 // *%$@!!!
|
|
|
1588 if(data.d) {
|
|
|
1589 data = data.d;
|
|
|
1590 if(typeof data === "string") {
|
|
|
1591 data = JSON.parse(data);
|
|
|
1592 }
|
|
|
1593 }
|
|
|
1594 if(!$.isArray(data)) { data = [data]; }
|
|
|
1595 var w = null,
|
|
|
1596 args = {
|
|
|
1597 'df' : this._model.default_state,
|
|
|
1598 'dat' : data,
|
|
|
1599 'par' : dom.id,
|
|
|
1600 'm' : this._model.data,
|
|
|
1601 't_id' : this._id,
|
|
|
1602 't_cnt' : this._cnt,
|
|
|
1603 'sel' : this._data.core.selected
|
|
|
1604 },
|
|
|
1605 func = function (data, undefined) {
|
|
|
1606 if(data.data) { data = data.data; }
|
|
|
1607 var dat = data.dat,
|
|
|
1608 par = data.par,
|
|
|
1609 chd = [],
|
|
|
1610 dpc = [],
|
|
|
1611 add = [],
|
|
|
1612 df = data.df,
|
|
|
1613 t_id = data.t_id,
|
|
|
1614 t_cnt = data.t_cnt,
|
|
|
1615 m = data.m,
|
|
|
1616 p = m[par],
|
|
|
1617 sel = data.sel,
|
|
|
1618 tmp, i, j, rslt,
|
|
|
1619 parse_flat = function (d, p, ps) {
|
|
|
1620 if(!ps) { ps = []; }
|
|
|
1621 else { ps = ps.concat(); }
|
|
|
1622 if(p) { ps.unshift(p); }
|
|
|
1623 var tid = d.id.toString(),
|
|
|
1624 i, j, c, e,
|
|
|
1625 tmp = {
|
|
|
1626 id : tid,
|
|
|
1627 text : d.text || '',
|
|
|
1628 icon : d.icon !== undefined ? d.icon : true,
|
|
|
1629 parent : p,
|
|
|
1630 parents : ps,
|
|
|
1631 children : d.children || [],
|
|
|
1632 children_d : d.children_d || [],
|
|
|
1633 data : d.data,
|
|
|
1634 state : { },
|
|
|
1635 li_attr : { id : false },
|
|
|
1636 a_attr : { href : '#' },
|
|
|
1637 original : false
|
|
|
1638 };
|
|
|
1639 for(i in df) {
|
|
|
1640 if(df.hasOwnProperty(i)) {
|
|
|
1641 tmp.state[i] = df[i];
|
|
|
1642 }
|
|
|
1643 }
|
|
|
1644 if(d && d.data && d.data.jstree && d.data.jstree.icon) {
|
|
|
1645 tmp.icon = d.data.jstree.icon;
|
|
|
1646 }
|
|
|
1647 if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {
|
|
|
1648 tmp.icon = true;
|
|
|
1649 }
|
|
|
1650 if(d && d.data) {
|
|
|
1651 tmp.data = d.data;
|
|
|
1652 if(d.data.jstree) {
|
|
|
1653 for(i in d.data.jstree) {
|
|
|
1654 if(d.data.jstree.hasOwnProperty(i)) {
|
|
|
1655 tmp.state[i] = d.data.jstree[i];
|
|
|
1656 }
|
|
|
1657 }
|
|
|
1658 }
|
|
|
1659 }
|
|
|
1660 if(d && typeof d.state === 'object') {
|
|
|
1661 for (i in d.state) {
|
|
|
1662 if(d.state.hasOwnProperty(i)) {
|
|
|
1663 tmp.state[i] = d.state[i];
|
|
|
1664 }
|
|
|
1665 }
|
|
|
1666 }
|
|
|
1667 if(d && typeof d.li_attr === 'object') {
|
|
|
1668 for (i in d.li_attr) {
|
|
|
1669 if(d.li_attr.hasOwnProperty(i)) {
|
|
|
1670 tmp.li_attr[i] = d.li_attr[i];
|
|
|
1671 }
|
|
|
1672 }
|
|
|
1673 }
|
|
|
1674 if(!tmp.li_attr.id) {
|
|
|
1675 tmp.li_attr.id = tid;
|
|
|
1676 }
|
|
|
1677 if(d && typeof d.a_attr === 'object') {
|
|
|
1678 for (i in d.a_attr) {
|
|
|
1679 if(d.a_attr.hasOwnProperty(i)) {
|
|
|
1680 tmp.a_attr[i] = d.a_attr[i];
|
|
|
1681 }
|
|
|
1682 }
|
|
|
1683 }
|
|
|
1684 if(d && d.children && d.children === true) {
|
|
|
1685 tmp.state.loaded = false;
|
|
|
1686 tmp.children = [];
|
|
|
1687 tmp.children_d = [];
|
|
|
1688 }
|
|
|
1689 m[tmp.id] = tmp;
|
|
|
1690 for(i = 0, j = tmp.children.length; i < j; i++) {
|
|
|
1691 c = parse_flat(m[tmp.children[i]], tmp.id, ps);
|
|
|
1692 e = m[c];
|
|
|
1693 tmp.children_d.push(c);
|
|
|
1694 if(e.children_d.length) {
|
|
|
1695 tmp.children_d = tmp.children_d.concat(e.children_d);
|
|
|
1696 }
|
|
|
1697 }
|
|
|
1698 delete d.data;
|
|
|
1699 delete d.children;
|
|
|
1700 m[tmp.id].original = d;
|
|
|
1701 if(tmp.state.selected) {
|
|
|
1702 add.push(tmp.id);
|
|
|
1703 }
|
|
|
1704 return tmp.id;
|
|
|
1705 },
|
|
|
1706 parse_nest = function (d, p, ps) {
|
|
|
1707 if(!ps) { ps = []; }
|
|
|
1708 else { ps = ps.concat(); }
|
|
|
1709 if(p) { ps.unshift(p); }
|
|
|
1710 var tid = false, i, j, c, e, tmp;
|
|
|
1711 do {
|
|
|
1712 tid = 'j' + t_id + '_' + (++t_cnt);
|
|
|
1713 } while(m[tid]);
|
|
|
1714
|
|
|
1715 tmp = {
|
|
|
1716 id : false,
|
|
|
1717 text : typeof d === 'string' ? d : '',
|
|
|
1718 icon : typeof d === 'object' && d.icon !== undefined ? d.icon : true,
|
|
|
1719 parent : p,
|
|
|
1720 parents : ps,
|
|
|
1721 children : [],
|
|
|
1722 children_d : [],
|
|
|
1723 data : null,
|
|
|
1724 state : { },
|
|
|
1725 li_attr : { id : false },
|
|
|
1726 a_attr : { href : '#' },
|
|
|
1727 original : false
|
|
|
1728 };
|
|
|
1729 for(i in df) {
|
|
|
1730 if(df.hasOwnProperty(i)) {
|
|
|
1731 tmp.state[i] = df[i];
|
|
|
1732 }
|
|
|
1733 }
|
|
|
1734 if(d && d.id) { tmp.id = d.id.toString(); }
|
|
|
1735 if(d && d.text) { tmp.text = d.text; }
|
|
|
1736 if(d && d.data && d.data.jstree && d.data.jstree.icon) {
|
|
|
1737 tmp.icon = d.data.jstree.icon;
|
|
|
1738 }
|
|
|
1739 if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {
|
|
|
1740 tmp.icon = true;
|
|
|
1741 }
|
|
|
1742 if(d && d.data) {
|
|
|
1743 tmp.data = d.data;
|
|
|
1744 if(d.data.jstree) {
|
|
|
1745 for(i in d.data.jstree) {
|
|
|
1746 if(d.data.jstree.hasOwnProperty(i)) {
|
|
|
1747 tmp.state[i] = d.data.jstree[i];
|
|
|
1748 }
|
|
|
1749 }
|
|
|
1750 }
|
|
|
1751 }
|
|
|
1752 if(d && typeof d.state === 'object') {
|
|
|
1753 for (i in d.state) {
|
|
|
1754 if(d.state.hasOwnProperty(i)) {
|
|
|
1755 tmp.state[i] = d.state[i];
|
|
|
1756 }
|
|
|
1757 }
|
|
|
1758 }
|
|
|
1759 if(d && typeof d.li_attr === 'object') {
|
|
|
1760 for (i in d.li_attr) {
|
|
|
1761 if(d.li_attr.hasOwnProperty(i)) {
|
|
|
1762 tmp.li_attr[i] = d.li_attr[i];
|
|
|
1763 }
|
|
|
1764 }
|
|
|
1765 }
|
|
|
1766 if(tmp.li_attr.id && !tmp.id) {
|
|
|
1767 tmp.id = tmp.li_attr.id.toString();
|
|
|
1768 }
|
|
|
1769 if(!tmp.id) {
|
|
|
1770 tmp.id = tid;
|
|
|
1771 }
|
|
|
1772 if(!tmp.li_attr.id) {
|
|
|
1773 tmp.li_attr.id = tmp.id;
|
|
|
1774 }
|
|
|
1775 if(d && typeof d.a_attr === 'object') {
|
|
|
1776 for (i in d.a_attr) {
|
|
|
1777 if(d.a_attr.hasOwnProperty(i)) {
|
|
|
1778 tmp.a_attr[i] = d.a_attr[i];
|
|
|
1779 }
|
|
|
1780 }
|
|
|
1781 }
|
|
|
1782 if(d && d.children && d.children.length) {
|
|
|
1783 for(i = 0, j = d.children.length; i < j; i++) {
|
|
|
1784 c = parse_nest(d.children[i], tmp.id, ps);
|
|
|
1785 e = m[c];
|
|
|
1786 tmp.children.push(c);
|
|
|
1787 if(e.children_d.length) {
|
|
|
1788 tmp.children_d = tmp.children_d.concat(e.children_d);
|
|
|
1789 }
|
|
|
1790 }
|
|
|
1791 tmp.children_d = tmp.children_d.concat(tmp.children);
|
|
|
1792 }
|
|
|
1793 if(d && d.children && d.children === true) {
|
|
|
1794 tmp.state.loaded = false;
|
|
|
1795 tmp.children = [];
|
|
|
1796 tmp.children_d = [];
|
|
|
1797 }
|
|
|
1798 delete d.data;
|
|
|
1799 delete d.children;
|
|
|
1800 tmp.original = d;
|
|
|
1801 m[tmp.id] = tmp;
|
|
|
1802 if(tmp.state.selected) {
|
|
|
1803 add.push(tmp.id);
|
|
|
1804 }
|
|
|
1805 return tmp.id;
|
|
|
1806 };
|
|
|
1807
|
|
|
1808 if(dat.length && dat[0].id !== undefined && dat[0].parent !== undefined) {
|
|
|
1809 // Flat JSON support (for easy import from DB):
|
|
|
1810 // 1) convert to object (foreach)
|
|
|
1811 for(i = 0, j = dat.length; i < j; i++) {
|
|
|
1812 if(!dat[i].children) {
|
|
|
1813 dat[i].children = [];
|
|
|
1814 }
|
|
|
1815 if(!dat[i].state) {
|
|
|
1816 dat[i].state = {};
|
|
|
1817 }
|
|
|
1818 m[dat[i].id.toString()] = dat[i];
|
|
|
1819 }
|
|
|
1820 // 2) populate children (foreach)
|
|
|
1821 for(i = 0, j = dat.length; i < j; i++) {
|
|
|
1822 if (!m[dat[i].parent.toString()]) {
|
|
|
1823 this._data.core.last_error = { 'error' : 'parse', 'plugin' : 'core', 'id' : 'core_07', 'reason' : 'Node with invalid parent', 'data' : JSON.stringify({ 'id' : dat[i].id.toString(), 'parent' : dat[i].parent.toString() }) };
|
|
|
1824 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
1825 continue;
|
|
|
1826 }
|
|
|
1827
|
|
|
1828 m[dat[i].parent.toString()].children.push(dat[i].id.toString());
|
|
|
1829 // populate parent.children_d
|
|
|
1830 p.children_d.push(dat[i].id.toString());
|
|
|
1831 }
|
|
|
1832 // 3) normalize && populate parents and children_d with recursion
|
|
|
1833 for(i = 0, j = p.children.length; i < j; i++) {
|
|
|
1834 tmp = parse_flat(m[p.children[i]], par, p.parents.concat());
|
|
|
1835 dpc.push(tmp);
|
|
|
1836 if(m[tmp].children_d.length) {
|
|
|
1837 dpc = dpc.concat(m[tmp].children_d);
|
|
|
1838 }
|
|
|
1839 }
|
|
|
1840 for(i = 0, j = p.parents.length; i < j; i++) {
|
|
|
1841 m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);
|
|
|
1842 }
|
|
|
1843 // ?) three_state selection - p.state.selected && t - (if three_state foreach(dat => ch) -> foreach(parents) if(parent.selected) child.selected = true;
|
|
|
1844 rslt = {
|
|
|
1845 'cnt' : t_cnt,
|
|
|
1846 'mod' : m,
|
|
|
1847 'sel' : sel,
|
|
|
1848 'par' : par,
|
|
|
1849 'dpc' : dpc,
|
|
|
1850 'add' : add
|
|
|
1851 };
|
|
|
1852 }
|
|
|
1853 else {
|
|
|
1854 for(i = 0, j = dat.length; i < j; i++) {
|
|
|
1855 tmp = parse_nest(dat[i], par, p.parents.concat());
|
|
|
1856 if(tmp) {
|
|
|
1857 chd.push(tmp);
|
|
|
1858 dpc.push(tmp);
|
|
|
1859 if(m[tmp].children_d.length) {
|
|
|
1860 dpc = dpc.concat(m[tmp].children_d);
|
|
|
1861 }
|
|
|
1862 }
|
|
|
1863 }
|
|
|
1864 p.children = chd;
|
|
|
1865 p.children_d = dpc;
|
|
|
1866 for(i = 0, j = p.parents.length; i < j; i++) {
|
|
|
1867 m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);
|
|
|
1868 }
|
|
|
1869 rslt = {
|
|
|
1870 'cnt' : t_cnt,
|
|
|
1871 'mod' : m,
|
|
|
1872 'sel' : sel,
|
|
|
1873 'par' : par,
|
|
|
1874 'dpc' : dpc,
|
|
|
1875 'add' : add
|
|
|
1876 };
|
|
|
1877 }
|
|
|
1878 if(typeof window === 'undefined' || typeof window.document === 'undefined') {
|
|
|
1879 postMessage(rslt);
|
|
|
1880 }
|
|
|
1881 else {
|
|
|
1882 return rslt;
|
|
|
1883 }
|
|
|
1884 },
|
|
|
1885 rslt = function (rslt, worker) {
|
|
|
1886 if(this.element === null) { return; }
|
|
|
1887 this._cnt = rslt.cnt;
|
|
|
1888 var i, m = this._model.data;
|
|
|
1889 for (i in m) {
|
|
|
1890 if (m.hasOwnProperty(i) && m[i].state && m[i].state.loading && rslt.mod[i]) {
|
|
|
1891 rslt.mod[i].state.loading = true;
|
|
|
1892 }
|
|
|
1893 }
|
|
|
1894 this._model.data = rslt.mod; // breaks the reference in load_node - careful
|
|
|
1895
|
|
|
1896 if(worker) {
|
|
|
1897 var j, a = rslt.add, r = rslt.sel, s = this._data.core.selected.slice();
|
|
|
1898 m = this._model.data;
|
|
|
1899 // if selection was changed while calculating in worker
|
|
|
1900 if(r.length !== s.length || $.vakata.array_unique(r.concat(s)).length !== r.length) {
|
|
|
1901 // deselect nodes that are no longer selected
|
|
|
1902 for(i = 0, j = r.length; i < j; i++) {
|
|
|
1903 if($.inArray(r[i], a) === -1 && $.inArray(r[i], s) === -1) {
|
|
|
1904 m[r[i]].state.selected = false;
|
|
|
1905 }
|
|
|
1906 }
|
|
|
1907 // select nodes that were selected in the mean time
|
|
|
1908 for(i = 0, j = s.length; i < j; i++) {
|
|
|
1909 if($.inArray(s[i], r) === -1) {
|
|
|
1910 m[s[i]].state.selected = true;
|
|
|
1911 }
|
|
|
1912 }
|
|
|
1913 }
|
|
|
1914 }
|
|
|
1915 if(rslt.add.length) {
|
|
|
1916 this._data.core.selected = this._data.core.selected.concat(rslt.add);
|
|
|
1917 }
|
|
|
1918
|
|
|
1919 this.trigger('model', { "nodes" : rslt.dpc, 'parent' : rslt.par });
|
|
|
1920
|
|
|
1921 if(rslt.par !== $.jstree.root) {
|
|
|
1922 this._node_changed(rslt.par);
|
|
|
1923 this.redraw();
|
|
|
1924 }
|
|
|
1925 else {
|
|
|
1926 // this.get_container_ul().children('.jstree-initial-node').remove();
|
|
|
1927 this.redraw(true);
|
|
|
1928 }
|
|
|
1929 if(rslt.add.length) {
|
|
|
1930 this.trigger('changed', { 'action' : 'model', 'selected' : this._data.core.selected });
|
|
|
1931 }
|
|
|
1932 cb.call(this, true);
|
|
|
1933 };
|
|
|
1934 if(this.settings.core.worker && window.Blob && window.URL && window.Worker) {
|
|
|
1935 try {
|
|
|
1936 if(this._wrk === null) {
|
|
|
1937 this._wrk = window.URL.createObjectURL(
|
|
|
1938 new window.Blob(
|
|
|
1939 ['self.onmessage = ' + func.toString()],
|
|
|
1940 {type:"text/javascript"}
|
|
|
1941 )
|
|
|
1942 );
|
|
|
1943 }
|
|
|
1944 if(!this._data.core.working || force_processing) {
|
|
|
1945 this._data.core.working = true;
|
|
|
1946 w = new window.Worker(this._wrk);
|
|
|
1947 w.onmessage = $.proxy(function (e) {
|
|
|
1948 rslt.call(this, e.data, true);
|
|
|
1949 try { w.terminate(); w = null; } catch(ignore) { }
|
|
|
1950 if(this._data.core.worker_queue.length) {
|
|
|
1951 this._append_json_data.apply(this, this._data.core.worker_queue.shift());
|
|
|
1952 }
|
|
|
1953 else {
|
|
|
1954 this._data.core.working = false;
|
|
|
1955 }
|
|
|
1956 }, this);
|
|
|
1957 if(!args.par) {
|
|
|
1958 if(this._data.core.worker_queue.length) {
|
|
|
1959 this._append_json_data.apply(this, this._data.core.worker_queue.shift());
|
|
|
1960 }
|
|
|
1961 else {
|
|
|
1962 this._data.core.working = false;
|
|
|
1963 }
|
|
|
1964 }
|
|
|
1965 else {
|
|
|
1966 w.postMessage(args);
|
|
|
1967 }
|
|
|
1968 }
|
|
|
1969 else {
|
|
|
1970 this._data.core.worker_queue.push([dom, data, cb, true]);
|
|
|
1971 }
|
|
|
1972 }
|
|
|
1973 catch(e) {
|
|
|
1974 rslt.call(this, func(args), false);
|
|
|
1975 if(this._data.core.worker_queue.length) {
|
|
|
1976 this._append_json_data.apply(this, this._data.core.worker_queue.shift());
|
|
|
1977 }
|
|
|
1978 else {
|
|
|
1979 this._data.core.working = false;
|
|
|
1980 }
|
|
|
1981 }
|
|
|
1982 }
|
|
|
1983 else {
|
|
|
1984 rslt.call(this, func(args), false);
|
|
|
1985 }
|
|
|
1986 },
|
|
|
1987 /**
|
|
|
1988 * parses a node from a jQuery object and appends them to the in memory tree model. Used internally.
|
|
|
1989 * @private
|
|
|
1990 * @name _parse_model_from_html(d [, p, ps])
|
|
|
1991 * @param {jQuery} d the jQuery object to parse
|
|
|
1992 * @param {String} p the parent ID
|
|
|
1993 * @param {Array} ps list of all parents
|
|
|
1994 * @return {String} the ID of the object added to the model
|
|
|
1995 */
|
|
|
1996 _parse_model_from_html : function (d, p, ps) {
|
|
|
1997 if(!ps) { ps = []; }
|
|
|
1998 else { ps = [].concat(ps); }
|
|
|
1999 if(p) { ps.unshift(p); }
|
|
|
2000 var c, e, m = this._model.data,
|
|
|
2001 data = {
|
|
|
2002 id : false,
|
|
|
2003 text : false,
|
|
|
2004 icon : true,
|
|
|
2005 parent : p,
|
|
|
2006 parents : ps,
|
|
|
2007 children : [],
|
|
|
2008 children_d : [],
|
|
|
2009 data : null,
|
|
|
2010 state : { },
|
|
|
2011 li_attr : { id : false },
|
|
|
2012 a_attr : { href : '#' },
|
|
|
2013 original : false
|
|
|
2014 }, i, tmp, tid;
|
|
|
2015 for(i in this._model.default_state) {
|
|
|
2016 if(this._model.default_state.hasOwnProperty(i)) {
|
|
|
2017 data.state[i] = this._model.default_state[i];
|
|
|
2018 }
|
|
|
2019 }
|
|
|
2020 tmp = $.vakata.attributes(d, true);
|
|
|
2021 $.each(tmp, function (i, v) {
|
|
|
2022 v = $.trim(v);
|
|
|
2023 if(!v.length) { return true; }
|
|
|
2024 data.li_attr[i] = v;
|
|
|
2025 if(i === 'id') {
|
|
|
2026 data.id = v.toString();
|
|
|
2027 }
|
|
|
2028 });
|
|
|
2029 tmp = d.children('a').first();
|
|
|
2030 if(tmp.length) {
|
|
|
2031 tmp = $.vakata.attributes(tmp, true);
|
|
|
2032 $.each(tmp, function (i, v) {
|
|
|
2033 v = $.trim(v);
|
|
|
2034 if(v.length) {
|
|
|
2035 data.a_attr[i] = v;
|
|
|
2036 }
|
|
|
2037 });
|
|
|
2038 }
|
|
|
2039 tmp = d.children("a").first().length ? d.children("a").first().clone() : d.clone();
|
|
|
2040 tmp.children("ins, i, ul").remove();
|
|
|
2041 tmp = tmp.html();
|
|
|
2042 tmp = $('<div />').html(tmp);
|
|
|
2043 data.text = this.settings.core.force_text ? tmp.text() : tmp.html();
|
|
|
2044 tmp = d.data();
|
|
|
2045 data.data = tmp ? $.extend(true, {}, tmp) : null;
|
|
|
2046 data.state.opened = d.hasClass('jstree-open');
|
|
|
2047 data.state.selected = d.children('a').hasClass('jstree-clicked');
|
|
|
2048 data.state.disabled = d.children('a').hasClass('jstree-disabled');
|
|
|
2049 if(data.data && data.data.jstree) {
|
|
|
2050 for(i in data.data.jstree) {
|
|
|
2051 if(data.data.jstree.hasOwnProperty(i)) {
|
|
|
2052 data.state[i] = data.data.jstree[i];
|
|
|
2053 }
|
|
|
2054 }
|
|
|
2055 }
|
|
|
2056 tmp = d.children("a").children(".jstree-themeicon");
|
|
|
2057 if(tmp.length) {
|
|
|
2058 data.icon = tmp.hasClass('jstree-themeicon-hidden') ? false : tmp.attr('rel');
|
|
|
2059 }
|
|
|
2060 if(data.state.icon !== undefined) {
|
|
|
2061 data.icon = data.state.icon;
|
|
|
2062 }
|
|
|
2063 if(data.icon === undefined || data.icon === null || data.icon === "") {
|
|
|
2064 data.icon = true;
|
|
|
2065 }
|
|
|
2066 tmp = d.children("ul").children("li");
|
|
|
2067 do {
|
|
|
2068 tid = 'j' + this._id + '_' + (++this._cnt);
|
|
|
2069 } while(m[tid]);
|
|
|
2070 data.id = data.li_attr.id ? data.li_attr.id.toString() : tid;
|
|
|
2071 if(tmp.length) {
|
|
|
2072 tmp.each($.proxy(function (i, v) {
|
|
|
2073 c = this._parse_model_from_html($(v), data.id, ps);
|
|
|
2074 e = this._model.data[c];
|
|
|
2075 data.children.push(c);
|
|
|
2076 if(e.children_d.length) {
|
|
|
2077 data.children_d = data.children_d.concat(e.children_d);
|
|
|
2078 }
|
|
|
2079 }, this));
|
|
|
2080 data.children_d = data.children_d.concat(data.children);
|
|
|
2081 }
|
|
|
2082 else {
|
|
|
2083 if(d.hasClass('jstree-closed')) {
|
|
|
2084 data.state.loaded = false;
|
|
|
2085 }
|
|
|
2086 }
|
|
|
2087 if(data.li_attr['class']) {
|
|
|
2088 data.li_attr['class'] = data.li_attr['class'].replace('jstree-closed','').replace('jstree-open','');
|
|
|
2089 }
|
|
|
2090 if(data.a_attr['class']) {
|
|
|
2091 data.a_attr['class'] = data.a_attr['class'].replace('jstree-clicked','').replace('jstree-disabled','');
|
|
|
2092 }
|
|
|
2093 m[data.id] = data;
|
|
|
2094 if(data.state.selected) {
|
|
|
2095 this._data.core.selected.push(data.id);
|
|
|
2096 }
|
|
|
2097 return data.id;
|
|
|
2098 },
|
|
|
2099 /**
|
|
|
2100 * parses a node from a JSON object (used when dealing with flat data, which has no nesting of children, but has id and parent properties) and appends it to the in memory tree model. Used internally.
|
|
|
2101 * @private
|
|
|
2102 * @name _parse_model_from_flat_json(d [, p, ps])
|
|
|
2103 * @param {Object} d the JSON object to parse
|
|
|
2104 * @param {String} p the parent ID
|
|
|
2105 * @param {Array} ps list of all parents
|
|
|
2106 * @return {String} the ID of the object added to the model
|
|
|
2107 */
|
|
|
2108 _parse_model_from_flat_json : function (d, p, ps) {
|
|
|
2109 if(!ps) { ps = []; }
|
|
|
2110 else { ps = ps.concat(); }
|
|
|
2111 if(p) { ps.unshift(p); }
|
|
|
2112 var tid = d.id.toString(),
|
|
|
2113 m = this._model.data,
|
|
|
2114 df = this._model.default_state,
|
|
|
2115 i, j, c, e,
|
|
|
2116 tmp = {
|
|
|
2117 id : tid,
|
|
|
2118 text : d.text || '',
|
|
|
2119 icon : d.icon !== undefined ? d.icon : true,
|
|
|
2120 parent : p,
|
|
|
2121 parents : ps,
|
|
|
2122 children : d.children || [],
|
|
|
2123 children_d : d.children_d || [],
|
|
|
2124 data : d.data,
|
|
|
2125 state : { },
|
|
|
2126 li_attr : { id : false },
|
|
|
2127 a_attr : { href : '#' },
|
|
|
2128 original : false
|
|
|
2129 };
|
|
|
2130 for(i in df) {
|
|
|
2131 if(df.hasOwnProperty(i)) {
|
|
|
2132 tmp.state[i] = df[i];
|
|
|
2133 }
|
|
|
2134 }
|
|
|
2135 if(d && d.data && d.data.jstree && d.data.jstree.icon) {
|
|
|
2136 tmp.icon = d.data.jstree.icon;
|
|
|
2137 }
|
|
|
2138 if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {
|
|
|
2139 tmp.icon = true;
|
|
|
2140 }
|
|
|
2141 if(d && d.data) {
|
|
|
2142 tmp.data = d.data;
|
|
|
2143 if(d.data.jstree) {
|
|
|
2144 for(i in d.data.jstree) {
|
|
|
2145 if(d.data.jstree.hasOwnProperty(i)) {
|
|
|
2146 tmp.state[i] = d.data.jstree[i];
|
|
|
2147 }
|
|
|
2148 }
|
|
|
2149 }
|
|
|
2150 }
|
|
|
2151 if(d && typeof d.state === 'object') {
|
|
|
2152 for (i in d.state) {
|
|
|
2153 if(d.state.hasOwnProperty(i)) {
|
|
|
2154 tmp.state[i] = d.state[i];
|
|
|
2155 }
|
|
|
2156 }
|
|
|
2157 }
|
|
|
2158 if(d && typeof d.li_attr === 'object') {
|
|
|
2159 for (i in d.li_attr) {
|
|
|
2160 if(d.li_attr.hasOwnProperty(i)) {
|
|
|
2161 tmp.li_attr[i] = d.li_attr[i];
|
|
|
2162 }
|
|
|
2163 }
|
|
|
2164 }
|
|
|
2165 if(!tmp.li_attr.id) {
|
|
|
2166 tmp.li_attr.id = tid;
|
|
|
2167 }
|
|
|
2168 if(d && typeof d.a_attr === 'object') {
|
|
|
2169 for (i in d.a_attr) {
|
|
|
2170 if(d.a_attr.hasOwnProperty(i)) {
|
|
|
2171 tmp.a_attr[i] = d.a_attr[i];
|
|
|
2172 }
|
|
|
2173 }
|
|
|
2174 }
|
|
|
2175 if(d && d.children && d.children === true) {
|
|
|
2176 tmp.state.loaded = false;
|
|
|
2177 tmp.children = [];
|
|
|
2178 tmp.children_d = [];
|
|
|
2179 }
|
|
|
2180 m[tmp.id] = tmp;
|
|
|
2181 for(i = 0, j = tmp.children.length; i < j; i++) {
|
|
|
2182 c = this._parse_model_from_flat_json(m[tmp.children[i]], tmp.id, ps);
|
|
|
2183 e = m[c];
|
|
|
2184 tmp.children_d.push(c);
|
|
|
2185 if(e.children_d.length) {
|
|
|
2186 tmp.children_d = tmp.children_d.concat(e.children_d);
|
|
|
2187 }
|
|
|
2188 }
|
|
|
2189 delete d.data;
|
|
|
2190 delete d.children;
|
|
|
2191 m[tmp.id].original = d;
|
|
|
2192 if(tmp.state.selected) {
|
|
|
2193 this._data.core.selected.push(tmp.id);
|
|
|
2194 }
|
|
|
2195 return tmp.id;
|
|
|
2196 },
|
|
|
2197 /**
|
|
|
2198 * parses a node from a JSON object and appends it to the in memory tree model. Used internally.
|
|
|
2199 * @private
|
|
|
2200 * @name _parse_model_from_json(d [, p, ps])
|
|
|
2201 * @param {Object} d the JSON object to parse
|
|
|
2202 * @param {String} p the parent ID
|
|
|
2203 * @param {Array} ps list of all parents
|
|
|
2204 * @return {String} the ID of the object added to the model
|
|
|
2205 */
|
|
|
2206 _parse_model_from_json : function (d, p, ps) {
|
|
|
2207 if(!ps) { ps = []; }
|
|
|
2208 else { ps = ps.concat(); }
|
|
|
2209 if(p) { ps.unshift(p); }
|
|
|
2210 var tid = false, i, j, c, e, m = this._model.data, df = this._model.default_state, tmp;
|
|
|
2211 do {
|
|
|
2212 tid = 'j' + this._id + '_' + (++this._cnt);
|
|
|
2213 } while(m[tid]);
|
|
|
2214
|
|
|
2215 tmp = {
|
|
|
2216 id : false,
|
|
|
2217 text : typeof d === 'string' ? d : '',
|
|
|
2218 icon : typeof d === 'object' && d.icon !== undefined ? d.icon : true,
|
|
|
2219 parent : p,
|
|
|
2220 parents : ps,
|
|
|
2221 children : [],
|
|
|
2222 children_d : [],
|
|
|
2223 data : null,
|
|
|
2224 state : { },
|
|
|
2225 li_attr : { id : false },
|
|
|
2226 a_attr : { href : '#' },
|
|
|
2227 original : false
|
|
|
2228 };
|
|
|
2229 for(i in df) {
|
|
|
2230 if(df.hasOwnProperty(i)) {
|
|
|
2231 tmp.state[i] = df[i];
|
|
|
2232 }
|
|
|
2233 }
|
|
|
2234 if(d && d.id) { tmp.id = d.id.toString(); }
|
|
|
2235 if(d && d.text) { tmp.text = d.text; }
|
|
|
2236 if(d && d.data && d.data.jstree && d.data.jstree.icon) {
|
|
|
2237 tmp.icon = d.data.jstree.icon;
|
|
|
2238 }
|
|
|
2239 if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {
|
|
|
2240 tmp.icon = true;
|
|
|
2241 }
|
|
|
2242 if(d && d.data) {
|
|
|
2243 tmp.data = d.data;
|
|
|
2244 if(d.data.jstree) {
|
|
|
2245 for(i in d.data.jstree) {
|
|
|
2246 if(d.data.jstree.hasOwnProperty(i)) {
|
|
|
2247 tmp.state[i] = d.data.jstree[i];
|
|
|
2248 }
|
|
|
2249 }
|
|
|
2250 }
|
|
|
2251 }
|
|
|
2252 if(d && typeof d.state === 'object') {
|
|
|
2253 for (i in d.state) {
|
|
|
2254 if(d.state.hasOwnProperty(i)) {
|
|
|
2255 tmp.state[i] = d.state[i];
|
|
|
2256 }
|
|
|
2257 }
|
|
|
2258 }
|
|
|
2259 if(d && typeof d.li_attr === 'object') {
|
|
|
2260 for (i in d.li_attr) {
|
|
|
2261 if(d.li_attr.hasOwnProperty(i)) {
|
|
|
2262 tmp.li_attr[i] = d.li_attr[i];
|
|
|
2263 }
|
|
|
2264 }
|
|
|
2265 }
|
|
|
2266 if(tmp.li_attr.id && !tmp.id) {
|
|
|
2267 tmp.id = tmp.li_attr.id.toString();
|
|
|
2268 }
|
|
|
2269 if(!tmp.id) {
|
|
|
2270 tmp.id = tid;
|
|
|
2271 }
|
|
|
2272 if(!tmp.li_attr.id) {
|
|
|
2273 tmp.li_attr.id = tmp.id;
|
|
|
2274 }
|
|
|
2275 if(d && typeof d.a_attr === 'object') {
|
|
|
2276 for (i in d.a_attr) {
|
|
|
2277 if(d.a_attr.hasOwnProperty(i)) {
|
|
|
2278 tmp.a_attr[i] = d.a_attr[i];
|
|
|
2279 }
|
|
|
2280 }
|
|
|
2281 }
|
|
|
2282 if(d && d.children && d.children.length) {
|
|
|
2283 for(i = 0, j = d.children.length; i < j; i++) {
|
|
|
2284 c = this._parse_model_from_json(d.children[i], tmp.id, ps);
|
|
|
2285 e = m[c];
|
|
|
2286 tmp.children.push(c);
|
|
|
2287 if(e.children_d.length) {
|
|
|
2288 tmp.children_d = tmp.children_d.concat(e.children_d);
|
|
|
2289 }
|
|
|
2290 }
|
|
|
2291 tmp.children_d = tmp.children_d.concat(tmp.children);
|
|
|
2292 }
|
|
|
2293 if(d && d.children && d.children === true) {
|
|
|
2294 tmp.state.loaded = false;
|
|
|
2295 tmp.children = [];
|
|
|
2296 tmp.children_d = [];
|
|
|
2297 }
|
|
|
2298 delete d.data;
|
|
|
2299 delete d.children;
|
|
|
2300 tmp.original = d;
|
|
|
2301 m[tmp.id] = tmp;
|
|
|
2302 if(tmp.state.selected) {
|
|
|
2303 this._data.core.selected.push(tmp.id);
|
|
|
2304 }
|
|
|
2305 return tmp.id;
|
|
|
2306 },
|
|
|
2307 /**
|
|
|
2308 * redraws all nodes that need to be redrawn. Used internally.
|
|
|
2309 * @private
|
|
|
2310 * @name _redraw()
|
|
|
2311 * @trigger redraw.jstree
|
|
|
2312 */
|
|
|
2313 _redraw : function () {
|
|
|
2314 var nodes = this._model.force_full_redraw ? this._model.data[$.jstree.root].children.concat([]) : this._model.changed.concat([]),
|
|
|
2315 f = document.createElement('UL'), tmp, i, j, fe = this._data.core.focused;
|
|
|
2316 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
2317 tmp = this.redraw_node(nodes[i], true, this._model.force_full_redraw);
|
|
|
2318 if(tmp && this._model.force_full_redraw) {
|
|
|
2319 f.appendChild(tmp);
|
|
|
2320 }
|
|
|
2321 }
|
|
|
2322 if(this._model.force_full_redraw) {
|
|
|
2323 f.className = this.get_container_ul()[0].className;
|
|
|
2324 f.setAttribute('role','group');
|
|
|
2325 this.element.empty().append(f);
|
|
|
2326 //this.get_container_ul()[0].appendChild(f);
|
|
|
2327 }
|
|
|
2328 if(fe !== null) {
|
|
|
2329 tmp = this.get_node(fe, true);
|
|
|
2330 if(tmp && tmp.length && tmp.children('.jstree-anchor')[0] !== document.activeElement) {
|
|
|
2331 tmp.children('.jstree-anchor').focus();
|
|
|
2332 }
|
|
|
2333 else {
|
|
|
2334 this._data.core.focused = null;
|
|
|
2335 }
|
|
|
2336 }
|
|
|
2337 this._model.force_full_redraw = false;
|
|
|
2338 this._model.changed = [];
|
|
|
2339 /**
|
|
|
2340 * triggered after nodes are redrawn
|
|
|
2341 * @event
|
|
|
2342 * @name redraw.jstree
|
|
|
2343 * @param {array} nodes the redrawn nodes
|
|
|
2344 */
|
|
|
2345 this.trigger('redraw', { "nodes" : nodes });
|
|
|
2346 },
|
|
|
2347 /**
|
|
|
2348 * redraws all nodes that need to be redrawn or optionally - the whole tree
|
|
|
2349 * @name redraw([full])
|
|
|
2350 * @param {Boolean} full if set to `true` all nodes are redrawn.
|
|
|
2351 */
|
|
|
2352 redraw : function (full) {
|
|
|
2353 if(full) {
|
|
|
2354 this._model.force_full_redraw = true;
|
|
|
2355 }
|
|
|
2356 //if(this._model.redraw_timeout) {
|
|
|
2357 // clearTimeout(this._model.redraw_timeout);
|
|
|
2358 //}
|
|
|
2359 //this._model.redraw_timeout = setTimeout($.proxy(this._redraw, this),0);
|
|
|
2360 this._redraw();
|
|
|
2361 },
|
|
|
2362 /**
|
|
|
2363 * redraws a single node's children. Used internally.
|
|
|
2364 * @private
|
|
|
2365 * @name draw_children(node)
|
|
|
2366 * @param {mixed} node the node whose children will be redrawn
|
|
|
2367 */
|
|
|
2368 draw_children : function (node) {
|
|
|
2369 var obj = this.get_node(node),
|
|
|
2370 i = false,
|
|
|
2371 j = false,
|
|
|
2372 k = false,
|
|
|
2373 d = document;
|
|
|
2374 if(!obj) { return false; }
|
|
|
2375 if(obj.id === $.jstree.root) { return this.redraw(true); }
|
|
|
2376 node = this.get_node(node, true);
|
|
|
2377 if(!node || !node.length) { return false; } // TODO: quick toggle
|
|
|
2378
|
|
|
2379 node.children('.jstree-children').remove();
|
|
|
2380 node = node[0];
|
|
|
2381 if(obj.children.length && obj.state.loaded) {
|
|
|
2382 k = d.createElement('UL');
|
|
|
2383 k.setAttribute('role', 'group');
|
|
|
2384 k.className = 'jstree-children';
|
|
|
2385 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
2386 k.appendChild(this.redraw_node(obj.children[i], true, true));
|
|
|
2387 }
|
|
|
2388 node.appendChild(k);
|
|
|
2389 }
|
|
|
2390 },
|
|
|
2391 /**
|
|
|
2392 * redraws a single node. Used internally.
|
|
|
2393 * @private
|
|
|
2394 * @name redraw_node(node, deep, is_callback, force_render)
|
|
|
2395 * @param {mixed} node the node to redraw
|
|
|
2396 * @param {Boolean} deep should child nodes be redrawn too
|
|
|
2397 * @param {Boolean} is_callback is this a recursion call
|
|
|
2398 * @param {Boolean} force_render should children of closed parents be drawn anyway
|
|
|
2399 */
|
|
|
2400 redraw_node : function (node, deep, is_callback, force_render) {
|
|
|
2401 var obj = this.get_node(node),
|
|
|
2402 par = false,
|
|
|
2403 ind = false,
|
|
|
2404 old = false,
|
|
|
2405 i = false,
|
|
|
2406 j = false,
|
|
|
2407 k = false,
|
|
|
2408 c = '',
|
|
|
2409 d = document,
|
|
|
2410 m = this._model.data,
|
|
|
2411 f = false,
|
|
|
2412 s = false,
|
|
|
2413 tmp = null,
|
|
|
2414 t = 0,
|
|
|
2415 l = 0,
|
|
|
2416 has_children = false,
|
|
|
2417 last_sibling = false;
|
|
|
2418 if(!obj) { return false; }
|
|
|
2419 if(obj.id === $.jstree.root) { return this.redraw(true); }
|
|
|
2420 deep = deep || obj.children.length === 0;
|
|
|
2421 node = !document.querySelector ? document.getElementById(obj.id) : this.element[0].querySelector('#' + ("0123456789".indexOf(obj.id[0]) !== -1 ? '\\3' + obj.id[0] + ' ' + obj.id.substr(1).replace($.jstree.idregex,'\\$&') : obj.id.replace($.jstree.idregex,'\\$&')) ); //, this.element);
|
|
|
2422 if(!node) {
|
|
|
2423 deep = true;
|
|
|
2424 //node = d.createElement('LI');
|
|
|
2425 if(!is_callback) {
|
|
|
2426 par = obj.parent !== $.jstree.root ? $('#' + obj.parent.replace($.jstree.idregex,'\\$&'), this.element)[0] : null;
|
|
|
2427 if(par !== null && (!par || !m[obj.parent].state.opened)) {
|
|
|
2428 return false;
|
|
|
2429 }
|
|
|
2430 ind = $.inArray(obj.id, par === null ? m[$.jstree.root].children : m[obj.parent].children);
|
|
|
2431 }
|
|
|
2432 }
|
|
|
2433 else {
|
|
|
2434 node = $(node);
|
|
|
2435 if(!is_callback) {
|
|
|
2436 par = node.parent().parent()[0];
|
|
|
2437 if(par === this.element[0]) {
|
|
|
2438 par = null;
|
|
|
2439 }
|
|
|
2440 ind = node.index();
|
|
|
2441 }
|
|
|
2442 // m[obj.id].data = node.data(); // use only node's data, no need to touch jquery storage
|
|
|
2443 if(!deep && obj.children.length && !node.children('.jstree-children').length) {
|
|
|
2444 deep = true;
|
|
|
2445 }
|
|
|
2446 if(!deep) {
|
|
|
2447 old = node.children('.jstree-children')[0];
|
|
|
2448 }
|
|
|
2449 f = node.children('.jstree-anchor')[0] === document.activeElement;
|
|
|
2450 node.remove();
|
|
|
2451 //node = d.createElement('LI');
|
|
|
2452 //node = node[0];
|
|
|
2453 }
|
|
|
2454 node = this._data.core.node.cloneNode(true);
|
|
|
2455 // node is DOM, deep is boolean
|
|
|
2456
|
|
|
2457 c = 'jstree-node ';
|
|
|
2458 for(i in obj.li_attr) {
|
|
|
2459 if(obj.li_attr.hasOwnProperty(i)) {
|
|
|
2460 if(i === 'id') { continue; }
|
|
|
2461 if(i !== 'class') {
|
|
|
2462 node.setAttribute(i, obj.li_attr[i]);
|
|
|
2463 }
|
|
|
2464 else {
|
|
|
2465 c += obj.li_attr[i];
|
|
|
2466 }
|
|
|
2467 }
|
|
|
2468 }
|
|
|
2469 if(!obj.a_attr.id) {
|
|
|
2470 obj.a_attr.id = obj.id + '_anchor';
|
|
|
2471 }
|
|
|
2472 node.setAttribute('aria-selected', !!obj.state.selected);
|
|
|
2473 node.setAttribute('aria-level', obj.parents.length);
|
|
|
2474 node.setAttribute('aria-labelledby', obj.a_attr.id);
|
|
|
2475 if(obj.state.disabled) {
|
|
|
2476 node.setAttribute('aria-disabled', true);
|
|
|
2477 }
|
|
|
2478
|
|
|
2479 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
2480 if(!m[obj.children[i]].state.hidden) {
|
|
|
2481 has_children = true;
|
|
|
2482 break;
|
|
|
2483 }
|
|
|
2484 }
|
|
|
2485 if(obj.parent !== null && m[obj.parent] && !obj.state.hidden) {
|
|
|
2486 i = $.inArray(obj.id, m[obj.parent].children);
|
|
|
2487 last_sibling = obj.id;
|
|
|
2488 if(i !== -1) {
|
|
|
2489 i++;
|
|
|
2490 for(j = m[obj.parent].children.length; i < j; i++) {
|
|
|
2491 if(!m[m[obj.parent].children[i]].state.hidden) {
|
|
|
2492 last_sibling = m[obj.parent].children[i];
|
|
|
2493 }
|
|
|
2494 if(last_sibling !== obj.id) {
|
|
|
2495 break;
|
|
|
2496 }
|
|
|
2497 }
|
|
|
2498 }
|
|
|
2499 }
|
|
|
2500
|
|
|
2501 if(obj.state.hidden) {
|
|
|
2502 c += ' jstree-hidden';
|
|
|
2503 }
|
|
|
2504 if (obj.state.loading) {
|
|
|
2505 c += ' jstree-loading';
|
|
|
2506 }
|
|
|
2507 if(obj.state.loaded && !has_children) {
|
|
|
2508 c += ' jstree-leaf';
|
|
|
2509 }
|
|
|
2510 else {
|
|
|
2511 c += obj.state.opened && obj.state.loaded ? ' jstree-open' : ' jstree-closed';
|
|
|
2512 node.setAttribute('aria-expanded', (obj.state.opened && obj.state.loaded) );
|
|
|
2513 }
|
|
|
2514 if(last_sibling === obj.id) {
|
|
|
2515 c += ' jstree-last';
|
|
|
2516 }
|
|
|
2517 node.id = obj.id;
|
|
|
2518 node.className = c;
|
|
|
2519 c = ( obj.state.selected ? ' jstree-clicked' : '') + ( obj.state.disabled ? ' jstree-disabled' : '');
|
|
|
2520 for(j in obj.a_attr) {
|
|
|
2521 if(obj.a_attr.hasOwnProperty(j)) {
|
|
|
2522 if(j === 'href' && obj.a_attr[j] === '#') { continue; }
|
|
|
2523 if(j !== 'class') {
|
|
|
2524 node.childNodes[1].setAttribute(j, obj.a_attr[j]);
|
|
|
2525 }
|
|
|
2526 else {
|
|
|
2527 c += ' ' + obj.a_attr[j];
|
|
|
2528 }
|
|
|
2529 }
|
|
|
2530 }
|
|
|
2531 if(c.length) {
|
|
|
2532 node.childNodes[1].className = 'jstree-anchor ' + c;
|
|
|
2533 }
|
|
|
2534 if((obj.icon && obj.icon !== true) || obj.icon === false) {
|
|
|
2535 if(obj.icon === false) {
|
|
|
2536 node.childNodes[1].childNodes[0].className += ' jstree-themeicon-hidden';
|
|
|
2537 }
|
|
|
2538 else if(obj.icon.indexOf('/') === -1 && obj.icon.indexOf('.') === -1) {
|
|
|
2539 node.childNodes[1].childNodes[0].className += ' ' + obj.icon + ' jstree-themeicon-custom';
|
|
|
2540 }
|
|
|
2541 else {
|
|
|
2542 node.childNodes[1].childNodes[0].style.backgroundImage = 'url("'+obj.icon+'")';
|
|
|
2543 node.childNodes[1].childNodes[0].style.backgroundPosition = 'center center';
|
|
|
2544 node.childNodes[1].childNodes[0].style.backgroundSize = 'auto';
|
|
|
2545 node.childNodes[1].childNodes[0].className += ' jstree-themeicon-custom';
|
|
|
2546 }
|
|
|
2547 }
|
|
|
2548
|
|
|
2549 if(this.settings.core.force_text) {
|
|
|
2550 node.childNodes[1].appendChild(d.createTextNode(obj.text));
|
|
|
2551 }
|
|
|
2552 else {
|
|
|
2553 node.childNodes[1].innerHTML += obj.text;
|
|
|
2554 }
|
|
|
2555
|
|
|
2556
|
|
|
2557 if(deep && obj.children.length && (obj.state.opened || force_render) && obj.state.loaded) {
|
|
|
2558 k = d.createElement('UL');
|
|
|
2559 k.setAttribute('role', 'group');
|
|
|
2560 k.className = 'jstree-children';
|
|
|
2561 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
2562 k.appendChild(this.redraw_node(obj.children[i], deep, true));
|
|
|
2563 }
|
|
|
2564 node.appendChild(k);
|
|
|
2565 }
|
|
|
2566 if(old) {
|
|
|
2567 node.appendChild(old);
|
|
|
2568 }
|
|
|
2569 if(!is_callback) {
|
|
|
2570 // append back using par / ind
|
|
|
2571 if(!par) {
|
|
|
2572 par = this.element[0];
|
|
|
2573 }
|
|
|
2574 for(i = 0, j = par.childNodes.length; i < j; i++) {
|
|
|
2575 if(par.childNodes[i] && par.childNodes[i].className && par.childNodes[i].className.indexOf('jstree-children') !== -1) {
|
|
|
2576 tmp = par.childNodes[i];
|
|
|
2577 break;
|
|
|
2578 }
|
|
|
2579 }
|
|
|
2580 if(!tmp) {
|
|
|
2581 tmp = d.createElement('UL');
|
|
|
2582 tmp.setAttribute('role', 'group');
|
|
|
2583 tmp.className = 'jstree-children';
|
|
|
2584 par.appendChild(tmp);
|
|
|
2585 }
|
|
|
2586 par = tmp;
|
|
|
2587
|
|
|
2588 if(ind < par.childNodes.length) {
|
|
|
2589 par.insertBefore(node, par.childNodes[ind]);
|
|
|
2590 }
|
|
|
2591 else {
|
|
|
2592 par.appendChild(node);
|
|
|
2593 }
|
|
|
2594 if(f) {
|
|
|
2595 t = this.element[0].scrollTop;
|
|
|
2596 l = this.element[0].scrollLeft;
|
|
|
2597 node.childNodes[1].focus();
|
|
|
2598 this.element[0].scrollTop = t;
|
|
|
2599 this.element[0].scrollLeft = l;
|
|
|
2600 }
|
|
|
2601 }
|
|
|
2602 if(obj.state.opened && !obj.state.loaded) {
|
|
|
2603 obj.state.opened = false;
|
|
|
2604 setTimeout($.proxy(function () {
|
|
|
2605 this.open_node(obj.id, false, 0);
|
|
|
2606 }, this), 0);
|
|
|
2607 }
|
|
|
2608 return node;
|
|
|
2609 },
|
|
|
2610 /**
|
|
|
2611 * opens a node, revaling its children. If the node is not loaded it will be loaded and opened once ready.
|
|
|
2612 * @name open_node(obj [, callback, animation])
|
|
|
2613 * @param {mixed} obj the node to open
|
|
|
2614 * @param {Function} callback a function to execute once the node is opened
|
|
|
2615 * @param {Number} animation the animation duration in milliseconds when opening the node (overrides the `core.animation` setting). Use `false` for no animation.
|
|
|
2616 * @trigger open_node.jstree, after_open.jstree, before_open.jstree
|
|
|
2617 */
|
|
|
2618 open_node : function (obj, callback, animation) {
|
|
|
2619 var t1, t2, d, t;
|
|
|
2620 if($.isArray(obj)) {
|
|
|
2621 obj = obj.slice();
|
|
|
2622 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2623 this.open_node(obj[t1], callback, animation);
|
|
|
2624 }
|
|
|
2625 return true;
|
|
|
2626 }
|
|
|
2627 obj = this.get_node(obj);
|
|
|
2628 if(!obj || obj.id === $.jstree.root) {
|
|
|
2629 return false;
|
|
|
2630 }
|
|
|
2631 animation = animation === undefined ? this.settings.core.animation : animation;
|
|
|
2632 if(!this.is_closed(obj)) {
|
|
|
2633 if(callback) {
|
|
|
2634 callback.call(this, obj, false);
|
|
|
2635 }
|
|
|
2636 return false;
|
|
|
2637 }
|
|
|
2638 if(!this.is_loaded(obj)) {
|
|
|
2639 if(this.is_loading(obj)) {
|
|
|
2640 return setTimeout($.proxy(function () {
|
|
|
2641 this.open_node(obj, callback, animation);
|
|
|
2642 }, this), 500);
|
|
|
2643 }
|
|
|
2644 this.load_node(obj, function (o, ok) {
|
|
|
2645 return ok ? this.open_node(o, callback, animation) : (callback ? callback.call(this, o, false) : false);
|
|
|
2646 });
|
|
|
2647 }
|
|
|
2648 else {
|
|
|
2649 d = this.get_node(obj, true);
|
|
|
2650 t = this;
|
|
|
2651 if(d.length) {
|
|
|
2652 if(animation && d.children(".jstree-children").length) {
|
|
|
2653 d.children(".jstree-children").stop(true, true);
|
|
|
2654 }
|
|
|
2655 if(obj.children.length && !this._firstChild(d.children('.jstree-children')[0])) {
|
|
|
2656 this.draw_children(obj);
|
|
|
2657 //d = this.get_node(obj, true);
|
|
|
2658 }
|
|
|
2659 if(!animation) {
|
|
|
2660 this.trigger('before_open', { "node" : obj });
|
|
|
2661 d[0].className = d[0].className.replace('jstree-closed', 'jstree-open');
|
|
|
2662 d[0].setAttribute("aria-expanded", true);
|
|
|
2663 }
|
|
|
2664 else {
|
|
|
2665 this.trigger('before_open', { "node" : obj });
|
|
|
2666 d
|
|
|
2667 .children(".jstree-children").css("display","none").end()
|
|
|
2668 .removeClass("jstree-closed").addClass("jstree-open").attr("aria-expanded", true)
|
|
|
2669 .children(".jstree-children").stop(true, true)
|
|
|
2670 .slideDown(animation, function () {
|
|
|
2671 this.style.display = "";
|
|
|
2672 if (t.element) {
|
|
|
2673 t.trigger("after_open", { "node" : obj });
|
|
|
2674 }
|
|
|
2675 });
|
|
|
2676 }
|
|
|
2677 }
|
|
|
2678 obj.state.opened = true;
|
|
|
2679 if(callback) {
|
|
|
2680 callback.call(this, obj, true);
|
|
|
2681 }
|
|
|
2682 if(!d.length) {
|
|
|
2683 /**
|
|
|
2684 * triggered when a node is about to be opened (if the node is supposed to be in the DOM, it will be, but it won't be visible yet)
|
|
|
2685 * @event
|
|
|
2686 * @name before_open.jstree
|
|
|
2687 * @param {Object} node the opened node
|
|
|
2688 */
|
|
|
2689 this.trigger('before_open', { "node" : obj });
|
|
|
2690 }
|
|
|
2691 /**
|
|
|
2692 * triggered when a node is opened (if there is an animation it will not be completed yet)
|
|
|
2693 * @event
|
|
|
2694 * @name open_node.jstree
|
|
|
2695 * @param {Object} node the opened node
|
|
|
2696 */
|
|
|
2697 this.trigger('open_node', { "node" : obj });
|
|
|
2698 if(!animation || !d.length) {
|
|
|
2699 /**
|
|
|
2700 * triggered when a node is opened and the animation is complete
|
|
|
2701 * @event
|
|
|
2702 * @name after_open.jstree
|
|
|
2703 * @param {Object} node the opened node
|
|
|
2704 */
|
|
|
2705 this.trigger("after_open", { "node" : obj });
|
|
|
2706 }
|
|
|
2707 return true;
|
|
|
2708 }
|
|
|
2709 },
|
|
|
2710 /**
|
|
|
2711 * opens every parent of a node (node should be loaded)
|
|
|
2712 * @name _open_to(obj)
|
|
|
2713 * @param {mixed} obj the node to reveal
|
|
|
2714 * @private
|
|
|
2715 */
|
|
|
2716 _open_to : function (obj) {
|
|
|
2717 obj = this.get_node(obj);
|
|
|
2718 if(!obj || obj.id === $.jstree.root) {
|
|
|
2719 return false;
|
|
|
2720 }
|
|
|
2721 var i, j, p = obj.parents;
|
|
|
2722 for(i = 0, j = p.length; i < j; i+=1) {
|
|
|
2723 if(i !== $.jstree.root) {
|
|
|
2724 this.open_node(p[i], false, 0);
|
|
|
2725 }
|
|
|
2726 }
|
|
|
2727 return $('#' + obj.id.replace($.jstree.idregex,'\\$&'), this.element);
|
|
|
2728 },
|
|
|
2729 /**
|
|
|
2730 * closes a node, hiding its children
|
|
|
2731 * @name close_node(obj [, animation])
|
|
|
2732 * @param {mixed} obj the node to close
|
|
|
2733 * @param {Number} animation the animation duration in milliseconds when closing the node (overrides the `core.animation` setting). Use `false` for no animation.
|
|
|
2734 * @trigger close_node.jstree, after_close.jstree
|
|
|
2735 */
|
|
|
2736 close_node : function (obj, animation) {
|
|
|
2737 var t1, t2, t, d;
|
|
|
2738 if($.isArray(obj)) {
|
|
|
2739 obj = obj.slice();
|
|
|
2740 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2741 this.close_node(obj[t1], animation);
|
|
|
2742 }
|
|
|
2743 return true;
|
|
|
2744 }
|
|
|
2745 obj = this.get_node(obj);
|
|
|
2746 if(!obj || obj.id === $.jstree.root) {
|
|
|
2747 return false;
|
|
|
2748 }
|
|
|
2749 if(this.is_closed(obj)) {
|
|
|
2750 return false;
|
|
|
2751 }
|
|
|
2752 animation = animation === undefined ? this.settings.core.animation : animation;
|
|
|
2753 t = this;
|
|
|
2754 d = this.get_node(obj, true);
|
|
|
2755
|
|
|
2756 obj.state.opened = false;
|
|
|
2757 /**
|
|
|
2758 * triggered when a node is closed (if there is an animation it will not be complete yet)
|
|
|
2759 * @event
|
|
|
2760 * @name close_node.jstree
|
|
|
2761 * @param {Object} node the closed node
|
|
|
2762 */
|
|
|
2763 this.trigger('close_node',{ "node" : obj });
|
|
|
2764 if(!d.length) {
|
|
|
2765 /**
|
|
|
2766 * triggered when a node is closed and the animation is complete
|
|
|
2767 * @event
|
|
|
2768 * @name after_close.jstree
|
|
|
2769 * @param {Object} node the closed node
|
|
|
2770 */
|
|
|
2771 this.trigger("after_close", { "node" : obj });
|
|
|
2772 }
|
|
|
2773 else {
|
|
|
2774 if(!animation) {
|
|
|
2775 d[0].className = d[0].className.replace('jstree-open', 'jstree-closed');
|
|
|
2776 d.attr("aria-expanded", false).children('.jstree-children').remove();
|
|
|
2777 this.trigger("after_close", { "node" : obj });
|
|
|
2778 }
|
|
|
2779 else {
|
|
|
2780 d
|
|
|
2781 .children(".jstree-children").attr("style","display:block !important").end()
|
|
|
2782 .removeClass("jstree-open").addClass("jstree-closed").attr("aria-expanded", false)
|
|
|
2783 .children(".jstree-children").stop(true, true).slideUp(animation, function () {
|
|
|
2784 this.style.display = "";
|
|
|
2785 d.children('.jstree-children').remove();
|
|
|
2786 if (t.element) {
|
|
|
2787 t.trigger("after_close", { "node" : obj });
|
|
|
2788 }
|
|
|
2789 });
|
|
|
2790 }
|
|
|
2791 }
|
|
|
2792 },
|
|
|
2793 /**
|
|
|
2794 * toggles a node - closing it if it is open, opening it if it is closed
|
|
|
2795 * @name toggle_node(obj)
|
|
|
2796 * @param {mixed} obj the node to toggle
|
|
|
2797 */
|
|
|
2798 toggle_node : function (obj) {
|
|
|
2799 var t1, t2;
|
|
|
2800 if($.isArray(obj)) {
|
|
|
2801 obj = obj.slice();
|
|
|
2802 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2803 this.toggle_node(obj[t1]);
|
|
|
2804 }
|
|
|
2805 return true;
|
|
|
2806 }
|
|
|
2807 if(this.is_closed(obj)) {
|
|
|
2808 return this.open_node(obj);
|
|
|
2809 }
|
|
|
2810 if(this.is_open(obj)) {
|
|
|
2811 return this.close_node(obj);
|
|
|
2812 }
|
|
|
2813 },
|
|
|
2814 /**
|
|
|
2815 * opens all nodes within a node (or the tree), revaling their children. If the node is not loaded it will be loaded and opened once ready.
|
|
|
2816 * @name open_all([obj, animation, original_obj])
|
|
|
2817 * @param {mixed} obj the node to open recursively, omit to open all nodes in the tree
|
|
|
2818 * @param {Number} animation the animation duration in milliseconds when opening the nodes, the default is no animation
|
|
|
2819 * @param {jQuery} reference to the node that started the process (internal use)
|
|
|
2820 * @trigger open_all.jstree
|
|
|
2821 */
|
|
|
2822 open_all : function (obj, animation, original_obj) {
|
|
|
2823 if(!obj) { obj = $.jstree.root; }
|
|
|
2824 obj = this.get_node(obj);
|
|
|
2825 if(!obj) { return false; }
|
|
|
2826 var dom = obj.id === $.jstree.root ? this.get_container_ul() : this.get_node(obj, true), i, j, _this;
|
|
|
2827 if(!dom.length) {
|
|
|
2828 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
2829 if(this.is_closed(this._model.data[obj.children_d[i]])) {
|
|
|
2830 this._model.data[obj.children_d[i]].state.opened = true;
|
|
|
2831 }
|
|
|
2832 }
|
|
|
2833 return this.trigger('open_all', { "node" : obj });
|
|
|
2834 }
|
|
|
2835 original_obj = original_obj || dom;
|
|
|
2836 _this = this;
|
|
|
2837 dom = this.is_closed(obj) ? dom.find('.jstree-closed').addBack() : dom.find('.jstree-closed');
|
|
|
2838 dom.each(function () {
|
|
|
2839 _this.open_node(
|
|
|
2840 this,
|
|
|
2841 function(node, status) { if(status && this.is_parent(node)) { this.open_all(node, animation, original_obj); } },
|
|
|
2842 animation || 0
|
|
|
2843 );
|
|
|
2844 });
|
|
|
2845 if(original_obj.find('.jstree-closed').length === 0) {
|
|
|
2846 /**
|
|
|
2847 * triggered when an `open_all` call completes
|
|
|
2848 * @event
|
|
|
2849 * @name open_all.jstree
|
|
|
2850 * @param {Object} node the opened node
|
|
|
2851 */
|
|
|
2852 this.trigger('open_all', { "node" : this.get_node(original_obj) });
|
|
|
2853 }
|
|
|
2854 },
|
|
|
2855 /**
|
|
|
2856 * closes all nodes within a node (or the tree), revaling their children
|
|
|
2857 * @name close_all([obj, animation])
|
|
|
2858 * @param {mixed} obj the node to close recursively, omit to close all nodes in the tree
|
|
|
2859 * @param {Number} animation the animation duration in milliseconds when closing the nodes, the default is no animation
|
|
|
2860 * @trigger close_all.jstree
|
|
|
2861 */
|
|
|
2862 close_all : function (obj, animation) {
|
|
|
2863 if(!obj) { obj = $.jstree.root; }
|
|
|
2864 obj = this.get_node(obj);
|
|
|
2865 if(!obj) { return false; }
|
|
|
2866 var dom = obj.id === $.jstree.root ? this.get_container_ul() : this.get_node(obj, true),
|
|
|
2867 _this = this, i, j;
|
|
|
2868 if(dom.length) {
|
|
|
2869 dom = this.is_open(obj) ? dom.find('.jstree-open').addBack() : dom.find('.jstree-open');
|
|
|
2870 $(dom.get().reverse()).each(function () { _this.close_node(this, animation || 0); });
|
|
|
2871 }
|
|
|
2872 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
2873 this._model.data[obj.children_d[i]].state.opened = false;
|
|
|
2874 }
|
|
|
2875 /**
|
|
|
2876 * triggered when an `close_all` call completes
|
|
|
2877 * @event
|
|
|
2878 * @name close_all.jstree
|
|
|
2879 * @param {Object} node the closed node
|
|
|
2880 */
|
|
|
2881 this.trigger('close_all', { "node" : obj });
|
|
|
2882 },
|
|
|
2883 /**
|
|
|
2884 * checks if a node is disabled (not selectable)
|
|
|
2885 * @name is_disabled(obj)
|
|
|
2886 * @param {mixed} obj
|
|
|
2887 * @return {Boolean}
|
|
|
2888 */
|
|
|
2889 is_disabled : function (obj) {
|
|
|
2890 obj = this.get_node(obj);
|
|
|
2891 return obj && obj.state && obj.state.disabled;
|
|
|
2892 },
|
|
|
2893 /**
|
|
|
2894 * enables a node - so that it can be selected
|
|
|
2895 * @name enable_node(obj)
|
|
|
2896 * @param {mixed} obj the node to enable
|
|
|
2897 * @trigger enable_node.jstree
|
|
|
2898 */
|
|
|
2899 enable_node : function (obj) {
|
|
|
2900 var t1, t2;
|
|
|
2901 if($.isArray(obj)) {
|
|
|
2902 obj = obj.slice();
|
|
|
2903 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2904 this.enable_node(obj[t1]);
|
|
|
2905 }
|
|
|
2906 return true;
|
|
|
2907 }
|
|
|
2908 obj = this.get_node(obj);
|
|
|
2909 if(!obj || obj.id === $.jstree.root) {
|
|
|
2910 return false;
|
|
|
2911 }
|
|
|
2912 obj.state.disabled = false;
|
|
|
2913 this.get_node(obj,true).children('.jstree-anchor').removeClass('jstree-disabled').attr('aria-disabled', false);
|
|
|
2914 /**
|
|
|
2915 * triggered when an node is enabled
|
|
|
2916 * @event
|
|
|
2917 * @name enable_node.jstree
|
|
|
2918 * @param {Object} node the enabled node
|
|
|
2919 */
|
|
|
2920 this.trigger('enable_node', { 'node' : obj });
|
|
|
2921 },
|
|
|
2922 /**
|
|
|
2923 * disables a node - so that it can not be selected
|
|
|
2924 * @name disable_node(obj)
|
|
|
2925 * @param {mixed} obj the node to disable
|
|
|
2926 * @trigger disable_node.jstree
|
|
|
2927 */
|
|
|
2928 disable_node : function (obj) {
|
|
|
2929 var t1, t2;
|
|
|
2930 if($.isArray(obj)) {
|
|
|
2931 obj = obj.slice();
|
|
|
2932 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2933 this.disable_node(obj[t1]);
|
|
|
2934 }
|
|
|
2935 return true;
|
|
|
2936 }
|
|
|
2937 obj = this.get_node(obj);
|
|
|
2938 if(!obj || obj.id === $.jstree.root) {
|
|
|
2939 return false;
|
|
|
2940 }
|
|
|
2941 obj.state.disabled = true;
|
|
|
2942 this.get_node(obj,true).children('.jstree-anchor').addClass('jstree-disabled').attr('aria-disabled', true);
|
|
|
2943 /**
|
|
|
2944 * triggered when an node is disabled
|
|
|
2945 * @event
|
|
|
2946 * @name disable_node.jstree
|
|
|
2947 * @param {Object} node the disabled node
|
|
|
2948 */
|
|
|
2949 this.trigger('disable_node', { 'node' : obj });
|
|
|
2950 },
|
|
|
2951 /**
|
|
|
2952 * determines if a node is hidden
|
|
|
2953 * @name is_hidden(obj)
|
|
|
2954 * @param {mixed} obj the node
|
|
|
2955 */
|
|
|
2956 is_hidden : function (obj) {
|
|
|
2957 obj = this.get_node(obj);
|
|
|
2958 return obj.state.hidden === true;
|
|
|
2959 },
|
|
|
2960 /**
|
|
|
2961 * hides a node - it is still in the structure but will not be visible
|
|
|
2962 * @name hide_node(obj)
|
|
|
2963 * @param {mixed} obj the node to hide
|
|
|
2964 * @param {Boolean} skip_redraw internal parameter controlling if redraw is called
|
|
|
2965 * @trigger hide_node.jstree
|
|
|
2966 */
|
|
|
2967 hide_node : function (obj, skip_redraw) {
|
|
|
2968 var t1, t2;
|
|
|
2969 if($.isArray(obj)) {
|
|
|
2970 obj = obj.slice();
|
|
|
2971 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
2972 this.hide_node(obj[t1], true);
|
|
|
2973 }
|
|
|
2974 if (!skip_redraw) {
|
|
|
2975 this.redraw();
|
|
|
2976 }
|
|
|
2977 return true;
|
|
|
2978 }
|
|
|
2979 obj = this.get_node(obj);
|
|
|
2980 if(!obj || obj.id === $.jstree.root) {
|
|
|
2981 return false;
|
|
|
2982 }
|
|
|
2983 if(!obj.state.hidden) {
|
|
|
2984 obj.state.hidden = true;
|
|
|
2985 this._node_changed(obj.parent);
|
|
|
2986 if(!skip_redraw) {
|
|
|
2987 this.redraw();
|
|
|
2988 }
|
|
|
2989 /**
|
|
|
2990 * triggered when an node is hidden
|
|
|
2991 * @event
|
|
|
2992 * @name hide_node.jstree
|
|
|
2993 * @param {Object} node the hidden node
|
|
|
2994 */
|
|
|
2995 this.trigger('hide_node', { 'node' : obj });
|
|
|
2996 }
|
|
|
2997 },
|
|
|
2998 /**
|
|
|
2999 * shows a node
|
|
|
3000 * @name show_node(obj)
|
|
|
3001 * @param {mixed} obj the node to show
|
|
|
3002 * @param {Boolean} skip_redraw internal parameter controlling if redraw is called
|
|
|
3003 * @trigger show_node.jstree
|
|
|
3004 */
|
|
|
3005 show_node : function (obj, skip_redraw) {
|
|
|
3006 var t1, t2;
|
|
|
3007 if($.isArray(obj)) {
|
|
|
3008 obj = obj.slice();
|
|
|
3009 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3010 this.show_node(obj[t1], true);
|
|
|
3011 }
|
|
|
3012 if (!skip_redraw) {
|
|
|
3013 this.redraw();
|
|
|
3014 }
|
|
|
3015 return true;
|
|
|
3016 }
|
|
|
3017 obj = this.get_node(obj);
|
|
|
3018 if(!obj || obj.id === $.jstree.root) {
|
|
|
3019 return false;
|
|
|
3020 }
|
|
|
3021 if(obj.state.hidden) {
|
|
|
3022 obj.state.hidden = false;
|
|
|
3023 this._node_changed(obj.parent);
|
|
|
3024 if(!skip_redraw) {
|
|
|
3025 this.redraw();
|
|
|
3026 }
|
|
|
3027 /**
|
|
|
3028 * triggered when an node is shown
|
|
|
3029 * @event
|
|
|
3030 * @name show_node.jstree
|
|
|
3031 * @param {Object} node the shown node
|
|
|
3032 */
|
|
|
3033 this.trigger('show_node', { 'node' : obj });
|
|
|
3034 }
|
|
|
3035 },
|
|
|
3036 /**
|
|
|
3037 * hides all nodes
|
|
|
3038 * @name hide_all()
|
|
|
3039 * @trigger hide_all.jstree
|
|
|
3040 */
|
|
|
3041 hide_all : function (skip_redraw) {
|
|
|
3042 var i, m = this._model.data, ids = [];
|
|
|
3043 for(i in m) {
|
|
|
3044 if(m.hasOwnProperty(i) && i !== $.jstree.root && !m[i].state.hidden) {
|
|
|
3045 m[i].state.hidden = true;
|
|
|
3046 ids.push(i);
|
|
|
3047 }
|
|
|
3048 }
|
|
|
3049 this._model.force_full_redraw = true;
|
|
|
3050 if(!skip_redraw) {
|
|
|
3051 this.redraw();
|
|
|
3052 }
|
|
|
3053 /**
|
|
|
3054 * triggered when all nodes are hidden
|
|
|
3055 * @event
|
|
|
3056 * @name hide_all.jstree
|
|
|
3057 * @param {Array} nodes the IDs of all hidden nodes
|
|
|
3058 */
|
|
|
3059 this.trigger('hide_all', { 'nodes' : ids });
|
|
|
3060 return ids;
|
|
|
3061 },
|
|
|
3062 /**
|
|
|
3063 * shows all nodes
|
|
|
3064 * @name show_all()
|
|
|
3065 * @trigger show_all.jstree
|
|
|
3066 */
|
|
|
3067 show_all : function (skip_redraw) {
|
|
|
3068 var i, m = this._model.data, ids = [];
|
|
|
3069 for(i in m) {
|
|
|
3070 if(m.hasOwnProperty(i) && i !== $.jstree.root && m[i].state.hidden) {
|
|
|
3071 m[i].state.hidden = false;
|
|
|
3072 ids.push(i);
|
|
|
3073 }
|
|
|
3074 }
|
|
|
3075 this._model.force_full_redraw = true;
|
|
|
3076 if(!skip_redraw) {
|
|
|
3077 this.redraw();
|
|
|
3078 }
|
|
|
3079 /**
|
|
|
3080 * triggered when all nodes are shown
|
|
|
3081 * @event
|
|
|
3082 * @name show_all.jstree
|
|
|
3083 * @param {Array} nodes the IDs of all shown nodes
|
|
|
3084 */
|
|
|
3085 this.trigger('show_all', { 'nodes' : ids });
|
|
|
3086 return ids;
|
|
|
3087 },
|
|
|
3088 /**
|
|
|
3089 * called when a node is selected by the user. Used internally.
|
|
|
3090 * @private
|
|
|
3091 * @name activate_node(obj, e)
|
|
|
3092 * @param {mixed} obj the node
|
|
|
3093 * @param {Object} e the related event
|
|
|
3094 * @trigger activate_node.jstree, changed.jstree
|
|
|
3095 */
|
|
|
3096 activate_node : function (obj, e) {
|
|
|
3097 if(this.is_disabled(obj)) {
|
|
|
3098 return false;
|
|
|
3099 }
|
|
|
3100 if(!e || typeof e !== 'object') {
|
|
|
3101 e = {};
|
|
|
3102 }
|
|
|
3103
|
|
|
3104 // ensure last_clicked is still in the DOM, make it fresh (maybe it was moved?) and make sure it is still selected, if not - make last_clicked the last selected node
|
|
|
3105 this._data.core.last_clicked = this._data.core.last_clicked && this._data.core.last_clicked.id !== undefined ? this.get_node(this._data.core.last_clicked.id) : null;
|
|
|
3106 if(this._data.core.last_clicked && !this._data.core.last_clicked.state.selected) { this._data.core.last_clicked = null; }
|
|
|
3107 if(!this._data.core.last_clicked && this._data.core.selected.length) { this._data.core.last_clicked = this.get_node(this._data.core.selected[this._data.core.selected.length - 1]); }
|
|
|
3108
|
|
|
3109 if(!this.settings.core.multiple || (!e.metaKey && !e.ctrlKey && !e.shiftKey) || (e.shiftKey && (!this._data.core.last_clicked || !this.get_parent(obj) || this.get_parent(obj) !== this._data.core.last_clicked.parent ) )) {
|
|
|
3110 if(!this.settings.core.multiple && (e.metaKey || e.ctrlKey || e.shiftKey) && this.is_selected(obj)) {
|
|
|
3111 this.deselect_node(obj, false, e);
|
|
|
3112 }
|
|
|
3113 else {
|
|
|
3114 this.deselect_all(true);
|
|
|
3115 this.select_node(obj, false, false, e);
|
|
|
3116 this._data.core.last_clicked = this.get_node(obj);
|
|
|
3117 }
|
|
|
3118 }
|
|
|
3119 else {
|
|
|
3120 if(e.shiftKey) {
|
|
|
3121 var o = this.get_node(obj).id,
|
|
|
3122 l = this._data.core.last_clicked.id,
|
|
|
3123 p = this.get_node(this._data.core.last_clicked.parent).children,
|
|
|
3124 c = false,
|
|
|
3125 i, j;
|
|
|
3126 for(i = 0, j = p.length; i < j; i += 1) {
|
|
|
3127 // separate IFs work whem o and l are the same
|
|
|
3128 if(p[i] === o) {
|
|
|
3129 c = !c;
|
|
|
3130 }
|
|
|
3131 if(p[i] === l) {
|
|
|
3132 c = !c;
|
|
|
3133 }
|
|
|
3134 if(!this.is_disabled(p[i]) && (c || p[i] === o || p[i] === l)) {
|
|
|
3135 if (!this.is_hidden(p[i])) {
|
|
|
3136 this.select_node(p[i], true, false, e);
|
|
|
3137 }
|
|
|
3138 }
|
|
|
3139 else {
|
|
|
3140 this.deselect_node(p[i], true, e);
|
|
|
3141 }
|
|
|
3142 }
|
|
|
3143 this.trigger('changed', { 'action' : 'select_node', 'node' : this.get_node(obj), 'selected' : this._data.core.selected, 'event' : e });
|
|
|
3144 }
|
|
|
3145 else {
|
|
|
3146 if(!this.is_selected(obj)) {
|
|
|
3147 this.select_node(obj, false, false, e);
|
|
|
3148 }
|
|
|
3149 else {
|
|
|
3150 this.deselect_node(obj, false, e);
|
|
|
3151 }
|
|
|
3152 }
|
|
|
3153 }
|
|
|
3154 /**
|
|
|
3155 * triggered when an node is clicked or intercated with by the user
|
|
|
3156 * @event
|
|
|
3157 * @name activate_node.jstree
|
|
|
3158 * @param {Object} node
|
|
|
3159 * @param {Object} event the ooriginal event (if any) which triggered the call (may be an empty object)
|
|
|
3160 */
|
|
|
3161 this.trigger('activate_node', { 'node' : this.get_node(obj), 'event' : e });
|
|
|
3162 },
|
|
|
3163 /**
|
|
|
3164 * applies the hover state on a node, called when a node is hovered by the user. Used internally.
|
|
|
3165 * @private
|
|
|
3166 * @name hover_node(obj)
|
|
|
3167 * @param {mixed} obj
|
|
|
3168 * @trigger hover_node.jstree
|
|
|
3169 */
|
|
|
3170 hover_node : function (obj) {
|
|
|
3171 obj = this.get_node(obj, true);
|
|
|
3172 if(!obj || !obj.length || obj.children('.jstree-hovered').length) {
|
|
|
3173 return false;
|
|
|
3174 }
|
|
|
3175 var o = this.element.find('.jstree-hovered'), t = this.element;
|
|
|
3176 if(o && o.length) { this.dehover_node(o); }
|
|
|
3177
|
|
|
3178 obj.children('.jstree-anchor').addClass('jstree-hovered');
|
|
|
3179 /**
|
|
|
3180 * triggered when an node is hovered
|
|
|
3181 * @event
|
|
|
3182 * @name hover_node.jstree
|
|
|
3183 * @param {Object} node
|
|
|
3184 */
|
|
|
3185 this.trigger('hover_node', { 'node' : this.get_node(obj) });
|
|
|
3186 setTimeout(function () { t.attr('aria-activedescendant', obj[0].id); }, 0);
|
|
|
3187 },
|
|
|
3188 /**
|
|
|
3189 * removes the hover state from a nodecalled when a node is no longer hovered by the user. Used internally.
|
|
|
3190 * @private
|
|
|
3191 * @name dehover_node(obj)
|
|
|
3192 * @param {mixed} obj
|
|
|
3193 * @trigger dehover_node.jstree
|
|
|
3194 */
|
|
|
3195 dehover_node : function (obj) {
|
|
|
3196 obj = this.get_node(obj, true);
|
|
|
3197 if(!obj || !obj.length || !obj.children('.jstree-hovered').length) {
|
|
|
3198 return false;
|
|
|
3199 }
|
|
|
3200 obj.children('.jstree-anchor').removeClass('jstree-hovered');
|
|
|
3201 /**
|
|
|
3202 * triggered when an node is no longer hovered
|
|
|
3203 * @event
|
|
|
3204 * @name dehover_node.jstree
|
|
|
3205 * @param {Object} node
|
|
|
3206 */
|
|
|
3207 this.trigger('dehover_node', { 'node' : this.get_node(obj) });
|
|
|
3208 },
|
|
|
3209 /**
|
|
|
3210 * select a node
|
|
|
3211 * @name select_node(obj [, supress_event, prevent_open])
|
|
|
3212 * @param {mixed} obj an array can be used to select multiple nodes
|
|
|
3213 * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered
|
|
|
3214 * @param {Boolean} prevent_open if set to `true` parents of the selected node won't be opened
|
|
|
3215 * @trigger select_node.jstree, changed.jstree
|
|
|
3216 */
|
|
|
3217 select_node : function (obj, supress_event, prevent_open, e) {
|
|
|
3218 var dom, t1, t2, th;
|
|
|
3219 if($.isArray(obj)) {
|
|
|
3220 obj = obj.slice();
|
|
|
3221 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3222 this.select_node(obj[t1], supress_event, prevent_open, e);
|
|
|
3223 }
|
|
|
3224 return true;
|
|
|
3225 }
|
|
|
3226 obj = this.get_node(obj);
|
|
|
3227 if(!obj || obj.id === $.jstree.root) {
|
|
|
3228 return false;
|
|
|
3229 }
|
|
|
3230 dom = this.get_node(obj, true);
|
|
|
3231 if(!obj.state.selected) {
|
|
|
3232 obj.state.selected = true;
|
|
|
3233 this._data.core.selected.push(obj.id);
|
|
|
3234 if(!prevent_open) {
|
|
|
3235 dom = this._open_to(obj);
|
|
|
3236 }
|
|
|
3237 if(dom && dom.length) {
|
|
|
3238 dom.attr('aria-selected', true).children('.jstree-anchor').addClass('jstree-clicked');
|
|
|
3239 }
|
|
|
3240 /**
|
|
|
3241 * triggered when an node is selected
|
|
|
3242 * @event
|
|
|
3243 * @name select_node.jstree
|
|
|
3244 * @param {Object} node
|
|
|
3245 * @param {Array} selected the current selection
|
|
|
3246 * @param {Object} event the event (if any) that triggered this select_node
|
|
|
3247 */
|
|
|
3248 this.trigger('select_node', { 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });
|
|
|
3249 if(!supress_event) {
|
|
|
3250 /**
|
|
|
3251 * triggered when selection changes
|
|
|
3252 * @event
|
|
|
3253 * @name changed.jstree
|
|
|
3254 * @param {Object} node
|
|
|
3255 * @param {Object} action the action that caused the selection to change
|
|
|
3256 * @param {Array} selected the current selection
|
|
|
3257 * @param {Object} event the event (if any) that triggered this changed event
|
|
|
3258 */
|
|
|
3259 this.trigger('changed', { 'action' : 'select_node', 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });
|
|
|
3260 }
|
|
|
3261 }
|
|
|
3262 },
|
|
|
3263 /**
|
|
|
3264 * deselect a node
|
|
|
3265 * @name deselect_node(obj [, supress_event])
|
|
|
3266 * @param {mixed} obj an array can be used to deselect multiple nodes
|
|
|
3267 * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered
|
|
|
3268 * @trigger deselect_node.jstree, changed.jstree
|
|
|
3269 */
|
|
|
3270 deselect_node : function (obj, supress_event, e) {
|
|
|
3271 var t1, t2, dom;
|
|
|
3272 if($.isArray(obj)) {
|
|
|
3273 obj = obj.slice();
|
|
|
3274 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3275 this.deselect_node(obj[t1], supress_event, e);
|
|
|
3276 }
|
|
|
3277 return true;
|
|
|
3278 }
|
|
|
3279 obj = this.get_node(obj);
|
|
|
3280 if(!obj || obj.id === $.jstree.root) {
|
|
|
3281 return false;
|
|
|
3282 }
|
|
|
3283 dom = this.get_node(obj, true);
|
|
|
3284 if(obj.state.selected) {
|
|
|
3285 obj.state.selected = false;
|
|
|
3286 this._data.core.selected = $.vakata.array_remove_item(this._data.core.selected, obj.id);
|
|
|
3287 if(dom.length) {
|
|
|
3288 dom.attr('aria-selected', false).children('.jstree-anchor').removeClass('jstree-clicked');
|
|
|
3289 }
|
|
|
3290 /**
|
|
|
3291 * triggered when an node is deselected
|
|
|
3292 * @event
|
|
|
3293 * @name deselect_node.jstree
|
|
|
3294 * @param {Object} node
|
|
|
3295 * @param {Array} selected the current selection
|
|
|
3296 * @param {Object} event the event (if any) that triggered this deselect_node
|
|
|
3297 */
|
|
|
3298 this.trigger('deselect_node', { 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });
|
|
|
3299 if(!supress_event) {
|
|
|
3300 this.trigger('changed', { 'action' : 'deselect_node', 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });
|
|
|
3301 }
|
|
|
3302 }
|
|
|
3303 },
|
|
|
3304 /**
|
|
|
3305 * select all nodes in the tree
|
|
|
3306 * @name select_all([supress_event])
|
|
|
3307 * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered
|
|
|
3308 * @trigger select_all.jstree, changed.jstree
|
|
|
3309 */
|
|
|
3310 select_all : function (supress_event) {
|
|
|
3311 var tmp = this._data.core.selected.concat([]), i, j;
|
|
|
3312 this._data.core.selected = this._model.data[$.jstree.root].children_d.concat();
|
|
|
3313 for(i = 0, j = this._data.core.selected.length; i < j; i++) {
|
|
|
3314 if(this._model.data[this._data.core.selected[i]]) {
|
|
|
3315 this._model.data[this._data.core.selected[i]].state.selected = true;
|
|
|
3316 }
|
|
|
3317 }
|
|
|
3318 this.redraw(true);
|
|
|
3319 /**
|
|
|
3320 * triggered when all nodes are selected
|
|
|
3321 * @event
|
|
|
3322 * @name select_all.jstree
|
|
|
3323 * @param {Array} selected the current selection
|
|
|
3324 */
|
|
|
3325 this.trigger('select_all', { 'selected' : this._data.core.selected });
|
|
|
3326 if(!supress_event) {
|
|
|
3327 this.trigger('changed', { 'action' : 'select_all', 'selected' : this._data.core.selected, 'old_selection' : tmp });
|
|
|
3328 }
|
|
|
3329 },
|
|
|
3330 /**
|
|
|
3331 * deselect all selected nodes
|
|
|
3332 * @name deselect_all([supress_event])
|
|
|
3333 * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered
|
|
|
3334 * @trigger deselect_all.jstree, changed.jstree
|
|
|
3335 */
|
|
|
3336 deselect_all : function (supress_event) {
|
|
|
3337 var tmp = this._data.core.selected.concat([]), i, j;
|
|
|
3338 for(i = 0, j = this._data.core.selected.length; i < j; i++) {
|
|
|
3339 if(this._model.data[this._data.core.selected[i]]) {
|
|
|
3340 this._model.data[this._data.core.selected[i]].state.selected = false;
|
|
|
3341 }
|
|
|
3342 }
|
|
|
3343 this._data.core.selected = [];
|
|
|
3344 this.element.find('.jstree-clicked').removeClass('jstree-clicked').parent().attr('aria-selected', false);
|
|
|
3345 /**
|
|
|
3346 * triggered when all nodes are deselected
|
|
|
3347 * @event
|
|
|
3348 * @name deselect_all.jstree
|
|
|
3349 * @param {Object} node the previous selection
|
|
|
3350 * @param {Array} selected the current selection
|
|
|
3351 */
|
|
|
3352 this.trigger('deselect_all', { 'selected' : this._data.core.selected, 'node' : tmp });
|
|
|
3353 if(!supress_event) {
|
|
|
3354 this.trigger('changed', { 'action' : 'deselect_all', 'selected' : this._data.core.selected, 'old_selection' : tmp });
|
|
|
3355 }
|
|
|
3356 },
|
|
|
3357 /**
|
|
|
3358 * checks if a node is selected
|
|
|
3359 * @name is_selected(obj)
|
|
|
3360 * @param {mixed} obj
|
|
|
3361 * @return {Boolean}
|
|
|
3362 */
|
|
|
3363 is_selected : function (obj) {
|
|
|
3364 obj = this.get_node(obj);
|
|
|
3365 if(!obj || obj.id === $.jstree.root) {
|
|
|
3366 return false;
|
|
|
3367 }
|
|
|
3368 return obj.state.selected;
|
|
|
3369 },
|
|
|
3370 /**
|
|
|
3371 * get an array of all selected nodes
|
|
|
3372 * @name get_selected([full])
|
|
|
3373 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
3374 * @return {Array}
|
|
|
3375 */
|
|
|
3376 get_selected : function (full) {
|
|
|
3377 return full ? $.map(this._data.core.selected, $.proxy(function (i) { return this.get_node(i); }, this)) : this._data.core.selected.slice();
|
|
|
3378 },
|
|
|
3379 /**
|
|
|
3380 * get an array of all top level selected nodes (ignoring children of selected nodes)
|
|
|
3381 * @name get_top_selected([full])
|
|
|
3382 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
3383 * @return {Array}
|
|
|
3384 */
|
|
|
3385 get_top_selected : function (full) {
|
|
|
3386 var tmp = this.get_selected(true),
|
|
|
3387 obj = {}, i, j, k, l;
|
|
|
3388 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
3389 obj[tmp[i].id] = tmp[i];
|
|
|
3390 }
|
|
|
3391 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
3392 for(k = 0, l = tmp[i].children_d.length; k < l; k++) {
|
|
|
3393 if(obj[tmp[i].children_d[k]]) {
|
|
|
3394 delete obj[tmp[i].children_d[k]];
|
|
|
3395 }
|
|
|
3396 }
|
|
|
3397 }
|
|
|
3398 tmp = [];
|
|
|
3399 for(i in obj) {
|
|
|
3400 if(obj.hasOwnProperty(i)) {
|
|
|
3401 tmp.push(i);
|
|
|
3402 }
|
|
|
3403 }
|
|
|
3404 return full ? $.map(tmp, $.proxy(function (i) { return this.get_node(i); }, this)) : tmp;
|
|
|
3405 },
|
|
|
3406 /**
|
|
|
3407 * get an array of all bottom level selected nodes (ignoring selected parents)
|
|
|
3408 * @name get_bottom_selected([full])
|
|
|
3409 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
3410 * @return {Array}
|
|
|
3411 */
|
|
|
3412 get_bottom_selected : function (full) {
|
|
|
3413 var tmp = this.get_selected(true),
|
|
|
3414 obj = [], i, j;
|
|
|
3415 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
3416 if(!tmp[i].children.length) {
|
|
|
3417 obj.push(tmp[i].id);
|
|
|
3418 }
|
|
|
3419 }
|
|
|
3420 return full ? $.map(obj, $.proxy(function (i) { return this.get_node(i); }, this)) : obj;
|
|
|
3421 },
|
|
|
3422 /**
|
|
|
3423 * gets the current state of the tree so that it can be restored later with `set_state(state)`. Used internally.
|
|
|
3424 * @name get_state()
|
|
|
3425 * @private
|
|
|
3426 * @return {Object}
|
|
|
3427 */
|
|
|
3428 get_state : function () {
|
|
|
3429 var state = {
|
|
|
3430 'core' : {
|
|
|
3431 'open' : [],
|
|
|
3432 'loaded' : [],
|
|
|
3433 'scroll' : {
|
|
|
3434 'left' : this.element.scrollLeft(),
|
|
|
3435 'top' : this.element.scrollTop()
|
|
|
3436 },
|
|
|
3437 /*!
|
|
|
3438 'themes' : {
|
|
|
3439 'name' : this.get_theme(),
|
|
|
3440 'icons' : this._data.core.themes.icons,
|
|
|
3441 'dots' : this._data.core.themes.dots
|
|
|
3442 },
|
|
|
3443 */
|
|
|
3444 'selected' : []
|
|
|
3445 }
|
|
|
3446 }, i;
|
|
|
3447 for(i in this._model.data) {
|
|
|
3448 if(this._model.data.hasOwnProperty(i)) {
|
|
|
3449 if(i !== $.jstree.root) {
|
|
|
3450 if(this._model.data[i].state.loaded && this.settings.core.loaded_state) {
|
|
|
3451 state.core.loaded.push(i);
|
|
|
3452 }
|
|
|
3453 if(this._model.data[i].state.opened) {
|
|
|
3454 state.core.open.push(i);
|
|
|
3455 }
|
|
|
3456 if(this._model.data[i].state.selected) {
|
|
|
3457 state.core.selected.push(i);
|
|
|
3458 }
|
|
|
3459 }
|
|
|
3460 }
|
|
|
3461 }
|
|
|
3462 return state;
|
|
|
3463 },
|
|
|
3464 /**
|
|
|
3465 * sets the state of the tree. Used internally.
|
|
|
3466 * @name set_state(state [, callback])
|
|
|
3467 * @private
|
|
|
3468 * @param {Object} state the state to restore. Keep in mind this object is passed by reference and jstree will modify it.
|
|
|
3469 * @param {Function} callback an optional function to execute once the state is restored.
|
|
|
3470 * @trigger set_state.jstree
|
|
|
3471 */
|
|
|
3472 set_state : function (state, callback) {
|
|
|
3473 if(state) {
|
|
|
3474 if(state.core && state.core.selected && state.core.initial_selection === undefined) {
|
|
|
3475 state.core.initial_selection = this._data.core.selected.concat([]).sort().join(',');
|
|
|
3476 }
|
|
|
3477 if(state.core) {
|
|
|
3478 var res, n, t, _this, i;
|
|
|
3479 if(state.core.loaded) {
|
|
|
3480 if(!this.settings.core.loaded_state || !$.isArray(state.core.loaded) || !state.core.loaded.length) {
|
|
|
3481 delete state.core.loaded;
|
|
|
3482 this.set_state(state, callback);
|
|
|
3483 }
|
|
|
3484 else {
|
|
|
3485 this._load_nodes(state.core.loaded, function (nodes) {
|
|
|
3486 delete state.core.loaded;
|
|
|
3487 this.set_state(state, callback);
|
|
|
3488 });
|
|
|
3489 }
|
|
|
3490 return false;
|
|
|
3491 }
|
|
|
3492 if(state.core.open) {
|
|
|
3493 if(!$.isArray(state.core.open) || !state.core.open.length) {
|
|
|
3494 delete state.core.open;
|
|
|
3495 this.set_state(state, callback);
|
|
|
3496 }
|
|
|
3497 else {
|
|
|
3498 this._load_nodes(state.core.open, function (nodes) {
|
|
|
3499 this.open_node(nodes, false, 0);
|
|
|
3500 delete state.core.open;
|
|
|
3501 this.set_state(state, callback);
|
|
|
3502 });
|
|
|
3503 }
|
|
|
3504 return false;
|
|
|
3505 }
|
|
|
3506 if(state.core.scroll) {
|
|
|
3507 if(state.core.scroll && state.core.scroll.left !== undefined) {
|
|
|
3508 this.element.scrollLeft(state.core.scroll.left);
|
|
|
3509 }
|
|
|
3510 if(state.core.scroll && state.core.scroll.top !== undefined) {
|
|
|
3511 this.element.scrollTop(state.core.scroll.top);
|
|
|
3512 }
|
|
|
3513 delete state.core.scroll;
|
|
|
3514 this.set_state(state, callback);
|
|
|
3515 return false;
|
|
|
3516 }
|
|
|
3517 if(state.core.selected) {
|
|
|
3518 _this = this;
|
|
|
3519 if (state.core.initial_selection === undefined ||
|
|
|
3520 state.core.initial_selection === this._data.core.selected.concat([]).sort().join(',')
|
|
|
3521 ) {
|
|
|
3522 this.deselect_all();
|
|
|
3523 $.each(state.core.selected, function (i, v) {
|
|
|
3524 _this.select_node(v, false, true);
|
|
|
3525 });
|
|
|
3526 }
|
|
|
3527 delete state.core.initial_selection;
|
|
|
3528 delete state.core.selected;
|
|
|
3529 this.set_state(state, callback);
|
|
|
3530 return false;
|
|
|
3531 }
|
|
|
3532 for(i in state) {
|
|
|
3533 if(state.hasOwnProperty(i) && i !== "core" && $.inArray(i, this.settings.plugins) === -1) {
|
|
|
3534 delete state[i];
|
|
|
3535 }
|
|
|
3536 }
|
|
|
3537 if($.isEmptyObject(state.core)) {
|
|
|
3538 delete state.core;
|
|
|
3539 this.set_state(state, callback);
|
|
|
3540 return false;
|
|
|
3541 }
|
|
|
3542 }
|
|
|
3543 if($.isEmptyObject(state)) {
|
|
|
3544 state = null;
|
|
|
3545 if(callback) { callback.call(this); }
|
|
|
3546 /**
|
|
|
3547 * triggered when a `set_state` call completes
|
|
|
3548 * @event
|
|
|
3549 * @name set_state.jstree
|
|
|
3550 */
|
|
|
3551 this.trigger('set_state');
|
|
|
3552 return false;
|
|
|
3553 }
|
|
|
3554 return true;
|
|
|
3555 }
|
|
|
3556 return false;
|
|
|
3557 },
|
|
|
3558 /**
|
|
|
3559 * refreshes the tree - all nodes are reloaded with calls to `load_node`.
|
|
|
3560 * @name refresh()
|
|
|
3561 * @param {Boolean} skip_loading an option to skip showing the loading indicator
|
|
|
3562 * @param {Mixed} forget_state if set to `true` state will not be reapplied, if set to a function (receiving the current state as argument) the result of that function will be used as state
|
|
|
3563 * @trigger refresh.jstree
|
|
|
3564 */
|
|
|
3565 refresh : function (skip_loading, forget_state) {
|
|
|
3566 this._data.core.state = forget_state === true ? {} : this.get_state();
|
|
|
3567 if(forget_state && $.isFunction(forget_state)) { this._data.core.state = forget_state.call(this, this._data.core.state); }
|
|
|
3568 this._cnt = 0;
|
|
|
3569 this._model.data = {};
|
|
|
3570 this._model.data[$.jstree.root] = {
|
|
|
3571 id : $.jstree.root,
|
|
|
3572 parent : null,
|
|
|
3573 parents : [],
|
|
|
3574 children : [],
|
|
|
3575 children_d : [],
|
|
|
3576 state : { loaded : false }
|
|
|
3577 };
|
|
|
3578 this._data.core.selected = [];
|
|
|
3579 this._data.core.last_clicked = null;
|
|
|
3580 this._data.core.focused = null;
|
|
|
3581
|
|
|
3582 var c = this.get_container_ul()[0].className;
|
|
|
3583 if(!skip_loading) {
|
|
|
3584 this.element.html("<"+"ul class='"+c+"' role='group'><"+"li class='jstree-initial-node jstree-loading jstree-leaf jstree-last' role='treeitem' id='j"+this._id+"_loading'><i class='jstree-icon jstree-ocl'></i><"+"a class='jstree-anchor' href='#'><i class='jstree-icon jstree-themeicon-hidden'></i>" + this.get_string("Loading ...") + "</a></li></ul>");
|
|
|
3585 this.element.attr('aria-activedescendant','j'+this._id+'_loading');
|
|
|
3586 }
|
|
|
3587 this.load_node($.jstree.root, function (o, s) {
|
|
|
3588 if(s) {
|
|
|
3589 this.get_container_ul()[0].className = c;
|
|
|
3590 if(this._firstChild(this.get_container_ul()[0])) {
|
|
|
3591 this.element.attr('aria-activedescendant',this._firstChild(this.get_container_ul()[0]).id);
|
|
|
3592 }
|
|
|
3593 this.set_state($.extend(true, {}, this._data.core.state), function () {
|
|
|
3594 /**
|
|
|
3595 * triggered when a `refresh` call completes
|
|
|
3596 * @event
|
|
|
3597 * @name refresh.jstree
|
|
|
3598 */
|
|
|
3599 this.trigger('refresh');
|
|
|
3600 });
|
|
|
3601 }
|
|
|
3602 this._data.core.state = null;
|
|
|
3603 });
|
|
|
3604 },
|
|
|
3605 /**
|
|
|
3606 * refreshes a node in the tree (reload its children) all opened nodes inside that node are reloaded with calls to `load_node`.
|
|
|
3607 * @name refresh_node(obj)
|
|
|
3608 * @param {mixed} obj the node
|
|
|
3609 * @trigger refresh_node.jstree
|
|
|
3610 */
|
|
|
3611 refresh_node : function (obj) {
|
|
|
3612 obj = this.get_node(obj);
|
|
|
3613 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
3614 var opened = [], to_load = [], s = this._data.core.selected.concat([]);
|
|
|
3615 to_load.push(obj.id);
|
|
|
3616 if(obj.state.opened === true) { opened.push(obj.id); }
|
|
|
3617 this.get_node(obj, true).find('.jstree-open').each(function() { to_load.push(this.id); opened.push(this.id); });
|
|
|
3618 this._load_nodes(to_load, $.proxy(function (nodes) {
|
|
|
3619 this.open_node(opened, false, 0);
|
|
|
3620 this.select_node(s);
|
|
|
3621 /**
|
|
|
3622 * triggered when a node is refreshed
|
|
|
3623 * @event
|
|
|
3624 * @name refresh_node.jstree
|
|
|
3625 * @param {Object} node - the refreshed node
|
|
|
3626 * @param {Array} nodes - an array of the IDs of the nodes that were reloaded
|
|
|
3627 */
|
|
|
3628 this.trigger('refresh_node', { 'node' : obj, 'nodes' : nodes });
|
|
|
3629 }, this), false, true);
|
|
|
3630 },
|
|
|
3631 /**
|
|
|
3632 * set (change) the ID of a node
|
|
|
3633 * @name set_id(obj, id)
|
|
|
3634 * @param {mixed} obj the node
|
|
|
3635 * @param {String} id the new ID
|
|
|
3636 * @return {Boolean}
|
|
|
3637 * @trigger set_id.jstree
|
|
|
3638 */
|
|
|
3639 set_id : function (obj, id) {
|
|
|
3640 obj = this.get_node(obj);
|
|
|
3641 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
3642 var i, j, m = this._model.data, old = obj.id;
|
|
|
3643 id = id.toString();
|
|
|
3644 // update parents (replace current ID with new one in children and children_d)
|
|
|
3645 m[obj.parent].children[$.inArray(obj.id, m[obj.parent].children)] = id;
|
|
|
3646 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
3647 m[obj.parents[i]].children_d[$.inArray(obj.id, m[obj.parents[i]].children_d)] = id;
|
|
|
3648 }
|
|
|
3649 // update children (replace current ID with new one in parent and parents)
|
|
|
3650 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
3651 m[obj.children[i]].parent = id;
|
|
|
3652 }
|
|
|
3653 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
3654 m[obj.children_d[i]].parents[$.inArray(obj.id, m[obj.children_d[i]].parents)] = id;
|
|
|
3655 }
|
|
|
3656 i = $.inArray(obj.id, this._data.core.selected);
|
|
|
3657 if(i !== -1) { this._data.core.selected[i] = id; }
|
|
|
3658 // update model and obj itself (obj.id, this._model.data[KEY])
|
|
|
3659 i = this.get_node(obj.id, true);
|
|
|
3660 if(i) {
|
|
|
3661 i.attr('id', id); //.children('.jstree-anchor').attr('id', id + '_anchor').end().attr('aria-labelledby', id + '_anchor');
|
|
|
3662 if(this.element.attr('aria-activedescendant') === obj.id) {
|
|
|
3663 this.element.attr('aria-activedescendant', id);
|
|
|
3664 }
|
|
|
3665 }
|
|
|
3666 delete m[obj.id];
|
|
|
3667 obj.id = id;
|
|
|
3668 obj.li_attr.id = id;
|
|
|
3669 m[id] = obj;
|
|
|
3670 /**
|
|
|
3671 * triggered when a node id value is changed
|
|
|
3672 * @event
|
|
|
3673 * @name set_id.jstree
|
|
|
3674 * @param {Object} node
|
|
|
3675 * @param {String} old the old id
|
|
|
3676 */
|
|
|
3677 this.trigger('set_id',{ "node" : obj, "new" : obj.id, "old" : old });
|
|
|
3678 return true;
|
|
|
3679 },
|
|
|
3680 /**
|
|
|
3681 * get the text value of a node
|
|
|
3682 * @name get_text(obj)
|
|
|
3683 * @param {mixed} obj the node
|
|
|
3684 * @return {String}
|
|
|
3685 */
|
|
|
3686 get_text : function (obj) {
|
|
|
3687 obj = this.get_node(obj);
|
|
|
3688 return (!obj || obj.id === $.jstree.root) ? false : obj.text;
|
|
|
3689 },
|
|
|
3690 /**
|
|
|
3691 * set the text value of a node. Used internally, please use `rename_node(obj, val)`.
|
|
|
3692 * @private
|
|
|
3693 * @name set_text(obj, val)
|
|
|
3694 * @param {mixed} obj the node, you can pass an array to set the text on multiple nodes
|
|
|
3695 * @param {String} val the new text value
|
|
|
3696 * @return {Boolean}
|
|
|
3697 * @trigger set_text.jstree
|
|
|
3698 */
|
|
|
3699 set_text : function (obj, val) {
|
|
|
3700 var t1, t2;
|
|
|
3701 if($.isArray(obj)) {
|
|
|
3702 obj = obj.slice();
|
|
|
3703 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3704 this.set_text(obj[t1], val);
|
|
|
3705 }
|
|
|
3706 return true;
|
|
|
3707 }
|
|
|
3708 obj = this.get_node(obj);
|
|
|
3709 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
3710 obj.text = val;
|
|
|
3711 if(this.get_node(obj, true).length) {
|
|
|
3712 this.redraw_node(obj.id);
|
|
|
3713 }
|
|
|
3714 /**
|
|
|
3715 * triggered when a node text value is changed
|
|
|
3716 * @event
|
|
|
3717 * @name set_text.jstree
|
|
|
3718 * @param {Object} obj
|
|
|
3719 * @param {String} text the new value
|
|
|
3720 */
|
|
|
3721 this.trigger('set_text',{ "obj" : obj, "text" : val });
|
|
|
3722 return true;
|
|
|
3723 },
|
|
|
3724 /**
|
|
|
3725 * gets a JSON representation of a node (or the whole tree)
|
|
|
3726 * @name get_json([obj, options])
|
|
|
3727 * @param {mixed} obj
|
|
|
3728 * @param {Object} options
|
|
|
3729 * @param {Boolean} options.no_state do not return state information
|
|
|
3730 * @param {Boolean} options.no_id do not return ID
|
|
|
3731 * @param {Boolean} options.no_children do not include children
|
|
|
3732 * @param {Boolean} options.no_data do not include node data
|
|
|
3733 * @param {Boolean} options.no_li_attr do not include LI attributes
|
|
|
3734 * @param {Boolean} options.no_a_attr do not include A attributes
|
|
|
3735 * @param {Boolean} options.flat return flat JSON instead of nested
|
|
|
3736 * @return {Object}
|
|
|
3737 */
|
|
|
3738 get_json : function (obj, options, flat) {
|
|
|
3739 obj = this.get_node(obj || $.jstree.root);
|
|
|
3740 if(!obj) { return false; }
|
|
|
3741 if(options && options.flat && !flat) { flat = []; }
|
|
|
3742 var tmp = {
|
|
|
3743 'id' : obj.id,
|
|
|
3744 'text' : obj.text,
|
|
|
3745 'icon' : this.get_icon(obj),
|
|
|
3746 'li_attr' : $.extend(true, {}, obj.li_attr),
|
|
|
3747 'a_attr' : $.extend(true, {}, obj.a_attr),
|
|
|
3748 'state' : {},
|
|
|
3749 'data' : options && options.no_data ? false : $.extend(true, $.isArray(obj.data)?[]:{}, obj.data)
|
|
|
3750 //( this.get_node(obj, true).length ? this.get_node(obj, true).data() : obj.data ),
|
|
|
3751 }, i, j;
|
|
|
3752 if(options && options.flat) {
|
|
|
3753 tmp.parent = obj.parent;
|
|
|
3754 }
|
|
|
3755 else {
|
|
|
3756 tmp.children = [];
|
|
|
3757 }
|
|
|
3758 if(!options || !options.no_state) {
|
|
|
3759 for(i in obj.state) {
|
|
|
3760 if(obj.state.hasOwnProperty(i)) {
|
|
|
3761 tmp.state[i] = obj.state[i];
|
|
|
3762 }
|
|
|
3763 }
|
|
|
3764 } else {
|
|
|
3765 delete tmp.state;
|
|
|
3766 }
|
|
|
3767 if(options && options.no_li_attr) {
|
|
|
3768 delete tmp.li_attr;
|
|
|
3769 }
|
|
|
3770 if(options && options.no_a_attr) {
|
|
|
3771 delete tmp.a_attr;
|
|
|
3772 }
|
|
|
3773 if(options && options.no_id) {
|
|
|
3774 delete tmp.id;
|
|
|
3775 if(tmp.li_attr && tmp.li_attr.id) {
|
|
|
3776 delete tmp.li_attr.id;
|
|
|
3777 }
|
|
|
3778 if(tmp.a_attr && tmp.a_attr.id) {
|
|
|
3779 delete tmp.a_attr.id;
|
|
|
3780 }
|
|
|
3781 }
|
|
|
3782 if(options && options.flat && obj.id !== $.jstree.root) {
|
|
|
3783 flat.push(tmp);
|
|
|
3784 }
|
|
|
3785 if(!options || !options.no_children) {
|
|
|
3786 for(i = 0, j = obj.children.length; i < j; i++) {
|
|
|
3787 if(options && options.flat) {
|
|
|
3788 this.get_json(obj.children[i], options, flat);
|
|
|
3789 }
|
|
|
3790 else {
|
|
|
3791 tmp.children.push(this.get_json(obj.children[i], options));
|
|
|
3792 }
|
|
|
3793 }
|
|
|
3794 }
|
|
|
3795 return options && options.flat ? flat : (obj.id === $.jstree.root ? tmp.children : tmp);
|
|
|
3796 },
|
|
|
3797 /**
|
|
|
3798 * create a new node (do not confuse with load_node)
|
|
|
3799 * @name create_node([par, node, pos, callback, is_loaded])
|
|
|
3800 * @param {mixed} par the parent node (to create a root node use either "#" (string) or `null`)
|
|
|
3801 * @param {mixed} node the data for the new node (a valid JSON object, or a simple string with the name)
|
|
|
3802 * @param {mixed} pos the index at which to insert the node, "first" and "last" are also supported, default is "last"
|
|
|
3803 * @param {Function} callback a function to be called once the node is created
|
|
|
3804 * @param {Boolean} is_loaded internal argument indicating if the parent node was succesfully loaded
|
|
|
3805 * @return {String} the ID of the newly create node
|
|
|
3806 * @trigger model.jstree, create_node.jstree
|
|
|
3807 */
|
|
|
3808 create_node : function (par, node, pos, callback, is_loaded) {
|
|
|
3809 if(par === null) { par = $.jstree.root; }
|
|
|
3810 par = this.get_node(par);
|
|
|
3811 if(!par) { return false; }
|
|
|
3812 pos = pos === undefined ? "last" : pos;
|
|
|
3813 if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {
|
|
|
3814 return this.load_node(par, function () { this.create_node(par, node, pos, callback, true); });
|
|
|
3815 }
|
|
|
3816 if(!node) { node = { "text" : this.get_string('New node') }; }
|
|
|
3817 if(typeof node === "string") {
|
|
|
3818 node = { "text" : node };
|
|
|
3819 } else {
|
|
|
3820 node = $.extend(true, {}, node);
|
|
|
3821 }
|
|
|
3822 if(node.text === undefined) { node.text = this.get_string('New node'); }
|
|
|
3823 var tmp, dpc, i, j;
|
|
|
3824
|
|
|
3825 if(par.id === $.jstree.root) {
|
|
|
3826 if(pos === "before") { pos = "first"; }
|
|
|
3827 if(pos === "after") { pos = "last"; }
|
|
|
3828 }
|
|
|
3829 switch(pos) {
|
|
|
3830 case "before":
|
|
|
3831 tmp = this.get_node(par.parent);
|
|
|
3832 pos = $.inArray(par.id, tmp.children);
|
|
|
3833 par = tmp;
|
|
|
3834 break;
|
|
|
3835 case "after" :
|
|
|
3836 tmp = this.get_node(par.parent);
|
|
|
3837 pos = $.inArray(par.id, tmp.children) + 1;
|
|
|
3838 par = tmp;
|
|
|
3839 break;
|
|
|
3840 case "inside":
|
|
|
3841 case "first":
|
|
|
3842 pos = 0;
|
|
|
3843 break;
|
|
|
3844 case "last":
|
|
|
3845 pos = par.children.length;
|
|
|
3846 break;
|
|
|
3847 default:
|
|
|
3848 if(!pos) { pos = 0; }
|
|
|
3849 break;
|
|
|
3850 }
|
|
|
3851 if(pos > par.children.length) { pos = par.children.length; }
|
|
|
3852 if(!node.id) { node.id = true; }
|
|
|
3853 if(!this.check("create_node", node, par, pos)) {
|
|
|
3854 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
3855 return false;
|
|
|
3856 }
|
|
|
3857 if(node.id === true) { delete node.id; }
|
|
|
3858 node = this._parse_model_from_json(node, par.id, par.parents.concat());
|
|
|
3859 if(!node) { return false; }
|
|
|
3860 tmp = this.get_node(node);
|
|
|
3861 dpc = [];
|
|
|
3862 dpc.push(node);
|
|
|
3863 dpc = dpc.concat(tmp.children_d);
|
|
|
3864 this.trigger('model', { "nodes" : dpc, "parent" : par.id });
|
|
|
3865
|
|
|
3866 par.children_d = par.children_d.concat(dpc);
|
|
|
3867 for(i = 0, j = par.parents.length; i < j; i++) {
|
|
|
3868 this._model.data[par.parents[i]].children_d = this._model.data[par.parents[i]].children_d.concat(dpc);
|
|
|
3869 }
|
|
|
3870 node = tmp;
|
|
|
3871 tmp = [];
|
|
|
3872 for(i = 0, j = par.children.length; i < j; i++) {
|
|
|
3873 tmp[i >= pos ? i+1 : i] = par.children[i];
|
|
|
3874 }
|
|
|
3875 tmp[pos] = node.id;
|
|
|
3876 par.children = tmp;
|
|
|
3877
|
|
|
3878 this.redraw_node(par, true);
|
|
|
3879 /**
|
|
|
3880 * triggered when a node is created
|
|
|
3881 * @event
|
|
|
3882 * @name create_node.jstree
|
|
|
3883 * @param {Object} node
|
|
|
3884 * @param {String} parent the parent's ID
|
|
|
3885 * @param {Number} position the position of the new node among the parent's children
|
|
|
3886 */
|
|
|
3887 this.trigger('create_node', { "node" : this.get_node(node), "parent" : par.id, "position" : pos });
|
|
|
3888 if(callback) { callback.call(this, this.get_node(node)); }
|
|
|
3889 return node.id;
|
|
|
3890 },
|
|
|
3891 /**
|
|
|
3892 * set the text value of a node
|
|
|
3893 * @name rename_node(obj, val)
|
|
|
3894 * @param {mixed} obj the node, you can pass an array to rename multiple nodes to the same name
|
|
|
3895 * @param {String} val the new text value
|
|
|
3896 * @return {Boolean}
|
|
|
3897 * @trigger rename_node.jstree
|
|
|
3898 */
|
|
|
3899 rename_node : function (obj, val) {
|
|
|
3900 var t1, t2, old;
|
|
|
3901 if($.isArray(obj)) {
|
|
|
3902 obj = obj.slice();
|
|
|
3903 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3904 this.rename_node(obj[t1], val);
|
|
|
3905 }
|
|
|
3906 return true;
|
|
|
3907 }
|
|
|
3908 obj = this.get_node(obj);
|
|
|
3909 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
3910 old = obj.text;
|
|
|
3911 if(!this.check("rename_node", obj, this.get_parent(obj), val)) {
|
|
|
3912 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
3913 return false;
|
|
|
3914 }
|
|
|
3915 this.set_text(obj, val); // .apply(this, Array.prototype.slice.call(arguments))
|
|
|
3916 /**
|
|
|
3917 * triggered when a node is renamed
|
|
|
3918 * @event
|
|
|
3919 * @name rename_node.jstree
|
|
|
3920 * @param {Object} node
|
|
|
3921 * @param {String} text the new value
|
|
|
3922 * @param {String} old the old value
|
|
|
3923 */
|
|
|
3924 this.trigger('rename_node', { "node" : obj, "text" : val, "old" : old });
|
|
|
3925 return true;
|
|
|
3926 },
|
|
|
3927 /**
|
|
|
3928 * remove a node
|
|
|
3929 * @name delete_node(obj)
|
|
|
3930 * @param {mixed} obj the node, you can pass an array to delete multiple nodes
|
|
|
3931 * @return {Boolean}
|
|
|
3932 * @trigger delete_node.jstree, changed.jstree
|
|
|
3933 */
|
|
|
3934 delete_node : function (obj) {
|
|
|
3935 var t1, t2, par, pos, tmp, i, j, k, l, c, top, lft;
|
|
|
3936 if($.isArray(obj)) {
|
|
|
3937 obj = obj.slice();
|
|
|
3938 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
3939 this.delete_node(obj[t1]);
|
|
|
3940 }
|
|
|
3941 return true;
|
|
|
3942 }
|
|
|
3943 obj = this.get_node(obj);
|
|
|
3944 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
3945 par = this.get_node(obj.parent);
|
|
|
3946 pos = $.inArray(obj.id, par.children);
|
|
|
3947 c = false;
|
|
|
3948 if(!this.check("delete_node", obj, par, pos)) {
|
|
|
3949 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
3950 return false;
|
|
|
3951 }
|
|
|
3952 if(pos !== -1) {
|
|
|
3953 par.children = $.vakata.array_remove(par.children, pos);
|
|
|
3954 }
|
|
|
3955 tmp = obj.children_d.concat([]);
|
|
|
3956 tmp.push(obj.id);
|
|
|
3957 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
3958 this._model.data[obj.parents[i]].children_d = $.vakata.array_filter(this._model.data[obj.parents[i]].children_d, function (v) {
|
|
|
3959 return $.inArray(v, tmp) === -1;
|
|
|
3960 });
|
|
|
3961 }
|
|
|
3962 for(k = 0, l = tmp.length; k < l; k++) {
|
|
|
3963 if(this._model.data[tmp[k]].state.selected) {
|
|
|
3964 c = true;
|
|
|
3965 break;
|
|
|
3966 }
|
|
|
3967 }
|
|
|
3968 if (c) {
|
|
|
3969 this._data.core.selected = $.vakata.array_filter(this._data.core.selected, function (v) {
|
|
|
3970 return $.inArray(v, tmp) === -1;
|
|
|
3971 });
|
|
|
3972 }
|
|
|
3973 /**
|
|
|
3974 * triggered when a node is deleted
|
|
|
3975 * @event
|
|
|
3976 * @name delete_node.jstree
|
|
|
3977 * @param {Object} node
|
|
|
3978 * @param {String} parent the parent's ID
|
|
|
3979 */
|
|
|
3980 this.trigger('delete_node', { "node" : obj, "parent" : par.id });
|
|
|
3981 if(c) {
|
|
|
3982 this.trigger('changed', { 'action' : 'delete_node', 'node' : obj, 'selected' : this._data.core.selected, 'parent' : par.id });
|
|
|
3983 }
|
|
|
3984 for(k = 0, l = tmp.length; k < l; k++) {
|
|
|
3985 delete this._model.data[tmp[k]];
|
|
|
3986 }
|
|
|
3987 if($.inArray(this._data.core.focused, tmp) !== -1) {
|
|
|
3988 this._data.core.focused = null;
|
|
|
3989 top = this.element[0].scrollTop;
|
|
|
3990 lft = this.element[0].scrollLeft;
|
|
|
3991 if(par.id === $.jstree.root) {
|
|
|
3992 if (this._model.data[$.jstree.root].children[0]) {
|
|
|
3993 this.get_node(this._model.data[$.jstree.root].children[0], true).children('.jstree-anchor').focus();
|
|
|
3994 }
|
|
|
3995 }
|
|
|
3996 else {
|
|
|
3997 this.get_node(par, true).children('.jstree-anchor').focus();
|
|
|
3998 }
|
|
|
3999 this.element[0].scrollTop = top;
|
|
|
4000 this.element[0].scrollLeft = lft;
|
|
|
4001 }
|
|
|
4002 this.redraw_node(par, true);
|
|
|
4003 return true;
|
|
|
4004 },
|
|
|
4005 /**
|
|
|
4006 * check if an operation is premitted on the tree. Used internally.
|
|
|
4007 * @private
|
|
|
4008 * @name check(chk, obj, par, pos)
|
|
|
4009 * @param {String} chk the operation to check, can be "create_node", "rename_node", "delete_node", "copy_node" or "move_node"
|
|
|
4010 * @param {mixed} obj the node
|
|
|
4011 * @param {mixed} par the parent
|
|
|
4012 * @param {mixed} pos the position to insert at, or if "rename_node" - the new name
|
|
|
4013 * @param {mixed} more some various additional information, for example if a "move_node" operations is triggered by DND this will be the hovered node
|
|
|
4014 * @return {Boolean}
|
|
|
4015 */
|
|
|
4016 check : function (chk, obj, par, pos, more) {
|
|
|
4017 obj = obj && obj.id ? obj : this.get_node(obj);
|
|
|
4018 par = par && par.id ? par : this.get_node(par);
|
|
|
4019 var tmp = chk.match(/^move_node|copy_node|create_node$/i) ? par : obj,
|
|
|
4020 chc = this.settings.core.check_callback;
|
|
|
4021 if(chk === "move_node" || chk === "copy_node") {
|
|
|
4022 if((!more || !more.is_multi) && (obj.id === par.id || (chk === "move_node" && $.inArray(obj.id, par.children) === pos) || $.inArray(par.id, obj.children_d) !== -1)) {
|
|
|
4023 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_01', 'reason' : 'Moving parent inside child', 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
4024 return false;
|
|
|
4025 }
|
|
|
4026 }
|
|
|
4027 if(tmp && tmp.data) { tmp = tmp.data; }
|
|
|
4028 if(tmp && tmp.functions && (tmp.functions[chk] === false || tmp.functions[chk] === true)) {
|
|
|
4029 if(tmp.functions[chk] === false) {
|
|
|
4030 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_02', 'reason' : 'Node data prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
4031 }
|
|
|
4032 return tmp.functions[chk];
|
|
|
4033 }
|
|
|
4034 if(chc === false || ($.isFunction(chc) && chc.call(this, chk, obj, par, pos, more) === false) || (chc && chc[chk] === false)) {
|
|
|
4035 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_03', 'reason' : 'User config for core.check_callback prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
4036 return false;
|
|
|
4037 }
|
|
|
4038 return true;
|
|
|
4039 },
|
|
|
4040 /**
|
|
|
4041 * get the last error
|
|
|
4042 * @name last_error()
|
|
|
4043 * @return {Object}
|
|
|
4044 */
|
|
|
4045 last_error : function () {
|
|
|
4046 return this._data.core.last_error;
|
|
|
4047 },
|
|
|
4048 /**
|
|
|
4049 * move a node to a new parent
|
|
|
4050 * @name move_node(obj, par [, pos, callback, is_loaded])
|
|
|
4051 * @param {mixed} obj the node to move, pass an array to move multiple nodes
|
|
|
4052 * @param {mixed} par the new parent
|
|
|
4053 * @param {mixed} pos the position to insert at (besides integer values, "first" and "last" are supported, as well as "before" and "after"), defaults to integer `0`
|
|
|
4054 * @param {function} callback a function to call once the move is completed, receives 3 arguments - the node, the new parent and the position
|
|
|
4055 * @param {Boolean} is_loaded internal parameter indicating if the parent node has been loaded
|
|
|
4056 * @param {Boolean} skip_redraw internal parameter indicating if the tree should be redrawn
|
|
|
4057 * @param {Boolean} instance internal parameter indicating if the node comes from another instance
|
|
|
4058 * @trigger move_node.jstree
|
|
|
4059 */
|
|
|
4060 move_node : function (obj, par, pos, callback, is_loaded, skip_redraw, origin) {
|
|
|
4061 var t1, t2, old_par, old_pos, new_par, old_ins, is_multi, dpc, tmp, i, j, k, l, p;
|
|
|
4062
|
|
|
4063 par = this.get_node(par);
|
|
|
4064 pos = pos === undefined ? 0 : pos;
|
|
|
4065 if(!par) { return false; }
|
|
|
4066 if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {
|
|
|
4067 return this.load_node(par, function () { this.move_node(obj, par, pos, callback, true, false, origin); });
|
|
|
4068 }
|
|
|
4069
|
|
|
4070 if($.isArray(obj)) {
|
|
|
4071 if(obj.length === 1) {
|
|
|
4072 obj = obj[0];
|
|
|
4073 }
|
|
|
4074 else {
|
|
|
4075 //obj = obj.slice();
|
|
|
4076 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4077 if((tmp = this.move_node(obj[t1], par, pos, callback, is_loaded, false, origin))) {
|
|
|
4078 par = tmp;
|
|
|
4079 pos = "after";
|
|
|
4080 }
|
|
|
4081 }
|
|
|
4082 this.redraw();
|
|
|
4083 return true;
|
|
|
4084 }
|
|
|
4085 }
|
|
|
4086 obj = obj && obj.id ? obj : this.get_node(obj);
|
|
|
4087
|
|
|
4088 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
4089
|
|
|
4090 old_par = (obj.parent || $.jstree.root).toString();
|
|
|
4091 new_par = (!pos.toString().match(/^(before|after)$/) || par.id === $.jstree.root) ? par : this.get_node(par.parent);
|
|
|
4092 old_ins = origin ? origin : (this._model.data[obj.id] ? this : $.jstree.reference(obj.id));
|
|
|
4093 is_multi = !old_ins || !old_ins._id || (this._id !== old_ins._id);
|
|
|
4094 old_pos = old_ins && old_ins._id && old_par && old_ins._model.data[old_par] && old_ins._model.data[old_par].children ? $.inArray(obj.id, old_ins._model.data[old_par].children) : -1;
|
|
|
4095 if(old_ins && old_ins._id) {
|
|
|
4096 obj = old_ins._model.data[obj.id];
|
|
|
4097 }
|
|
|
4098
|
|
|
4099 if(is_multi) {
|
|
|
4100 if((tmp = this.copy_node(obj, par, pos, callback, is_loaded, false, origin))) {
|
|
|
4101 if(old_ins) { old_ins.delete_node(obj); }
|
|
|
4102 return tmp;
|
|
|
4103 }
|
|
|
4104 return false;
|
|
|
4105 }
|
|
|
4106 //var m = this._model.data;
|
|
|
4107 if(par.id === $.jstree.root) {
|
|
|
4108 if(pos === "before") { pos = "first"; }
|
|
|
4109 if(pos === "after") { pos = "last"; }
|
|
|
4110 }
|
|
|
4111 switch(pos) {
|
|
|
4112 case "before":
|
|
|
4113 pos = $.inArray(par.id, new_par.children);
|
|
|
4114 break;
|
|
|
4115 case "after" :
|
|
|
4116 pos = $.inArray(par.id, new_par.children) + 1;
|
|
|
4117 break;
|
|
|
4118 case "inside":
|
|
|
4119 case "first":
|
|
|
4120 pos = 0;
|
|
|
4121 break;
|
|
|
4122 case "last":
|
|
|
4123 pos = new_par.children.length;
|
|
|
4124 break;
|
|
|
4125 default:
|
|
|
4126 if(!pos) { pos = 0; }
|
|
|
4127 break;
|
|
|
4128 }
|
|
|
4129 if(pos > new_par.children.length) { pos = new_par.children.length; }
|
|
|
4130 if(!this.check("move_node", obj, new_par, pos, { 'core' : true, 'origin' : origin, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id) })) {
|
|
|
4131 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
4132 return false;
|
|
|
4133 }
|
|
|
4134 if(obj.parent === new_par.id) {
|
|
|
4135 dpc = new_par.children.concat();
|
|
|
4136 tmp = $.inArray(obj.id, dpc);
|
|
|
4137 if(tmp !== -1) {
|
|
|
4138 dpc = $.vakata.array_remove(dpc, tmp);
|
|
|
4139 if(pos > tmp) { pos--; }
|
|
|
4140 }
|
|
|
4141 tmp = [];
|
|
|
4142 for(i = 0, j = dpc.length; i < j; i++) {
|
|
|
4143 tmp[i >= pos ? i+1 : i] = dpc[i];
|
|
|
4144 }
|
|
|
4145 tmp[pos] = obj.id;
|
|
|
4146 new_par.children = tmp;
|
|
|
4147 this._node_changed(new_par.id);
|
|
|
4148 this.redraw(new_par.id === $.jstree.root);
|
|
|
4149 }
|
|
|
4150 else {
|
|
|
4151 // clean old parent and up
|
|
|
4152 tmp = obj.children_d.concat();
|
|
|
4153 tmp.push(obj.id);
|
|
|
4154 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
4155 dpc = [];
|
|
|
4156 p = old_ins._model.data[obj.parents[i]].children_d;
|
|
|
4157 for(k = 0, l = p.length; k < l; k++) {
|
|
|
4158 if($.inArray(p[k], tmp) === -1) {
|
|
|
4159 dpc.push(p[k]);
|
|
|
4160 }
|
|
|
4161 }
|
|
|
4162 old_ins._model.data[obj.parents[i]].children_d = dpc;
|
|
|
4163 }
|
|
|
4164 old_ins._model.data[old_par].children = $.vakata.array_remove_item(old_ins._model.data[old_par].children, obj.id);
|
|
|
4165
|
|
|
4166 // insert into new parent and up
|
|
|
4167 for(i = 0, j = new_par.parents.length; i < j; i++) {
|
|
|
4168 this._model.data[new_par.parents[i]].children_d = this._model.data[new_par.parents[i]].children_d.concat(tmp);
|
|
|
4169 }
|
|
|
4170 dpc = [];
|
|
|
4171 for(i = 0, j = new_par.children.length; i < j; i++) {
|
|
|
4172 dpc[i >= pos ? i+1 : i] = new_par.children[i];
|
|
|
4173 }
|
|
|
4174 dpc[pos] = obj.id;
|
|
|
4175 new_par.children = dpc;
|
|
|
4176 new_par.children_d.push(obj.id);
|
|
|
4177 new_par.children_d = new_par.children_d.concat(obj.children_d);
|
|
|
4178
|
|
|
4179 // update object
|
|
|
4180 obj.parent = new_par.id;
|
|
|
4181 tmp = new_par.parents.concat();
|
|
|
4182 tmp.unshift(new_par.id);
|
|
|
4183 p = obj.parents.length;
|
|
|
4184 obj.parents = tmp;
|
|
|
4185
|
|
|
4186 // update object children
|
|
|
4187 tmp = tmp.concat();
|
|
|
4188 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
4189 this._model.data[obj.children_d[i]].parents = this._model.data[obj.children_d[i]].parents.slice(0,p*-1);
|
|
|
4190 Array.prototype.push.apply(this._model.data[obj.children_d[i]].parents, tmp);
|
|
|
4191 }
|
|
|
4192
|
|
|
4193 if(old_par === $.jstree.root || new_par.id === $.jstree.root) {
|
|
|
4194 this._model.force_full_redraw = true;
|
|
|
4195 }
|
|
|
4196 if(!this._model.force_full_redraw) {
|
|
|
4197 this._node_changed(old_par);
|
|
|
4198 this._node_changed(new_par.id);
|
|
|
4199 }
|
|
|
4200 if(!skip_redraw) {
|
|
|
4201 this.redraw();
|
|
|
4202 }
|
|
|
4203 }
|
|
|
4204 if(callback) { callback.call(this, obj, new_par, pos); }
|
|
|
4205 /**
|
|
|
4206 * triggered when a node is moved
|
|
|
4207 * @event
|
|
|
4208 * @name move_node.jstree
|
|
|
4209 * @param {Object} node
|
|
|
4210 * @param {String} parent the parent's ID
|
|
|
4211 * @param {Number} position the position of the node among the parent's children
|
|
|
4212 * @param {String} old_parent the old parent of the node
|
|
|
4213 * @param {Number} old_position the old position of the node
|
|
|
4214 * @param {Boolean} is_multi do the node and new parent belong to different instances
|
|
|
4215 * @param {jsTree} old_instance the instance the node came from
|
|
|
4216 * @param {jsTree} new_instance the instance of the new parent
|
|
|
4217 */
|
|
|
4218 this.trigger('move_node', { "node" : obj, "parent" : new_par.id, "position" : pos, "old_parent" : old_par, "old_position" : old_pos, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id), 'old_instance' : old_ins, 'new_instance' : this });
|
|
|
4219 return obj.id;
|
|
|
4220 },
|
|
|
4221 /**
|
|
|
4222 * copy a node to a new parent
|
|
|
4223 * @name copy_node(obj, par [, pos, callback, is_loaded])
|
|
|
4224 * @param {mixed} obj the node to copy, pass an array to copy multiple nodes
|
|
|
4225 * @param {mixed} par the new parent
|
|
|
4226 * @param {mixed} pos the position to insert at (besides integer values, "first" and "last" are supported, as well as "before" and "after"), defaults to integer `0`
|
|
|
4227 * @param {function} callback a function to call once the move is completed, receives 3 arguments - the node, the new parent and the position
|
|
|
4228 * @param {Boolean} is_loaded internal parameter indicating if the parent node has been loaded
|
|
|
4229 * @param {Boolean} skip_redraw internal parameter indicating if the tree should be redrawn
|
|
|
4230 * @param {Boolean} instance internal parameter indicating if the node comes from another instance
|
|
|
4231 * @trigger model.jstree copy_node.jstree
|
|
|
4232 */
|
|
|
4233 copy_node : function (obj, par, pos, callback, is_loaded, skip_redraw, origin) {
|
|
|
4234 var t1, t2, dpc, tmp, i, j, node, old_par, new_par, old_ins, is_multi;
|
|
|
4235
|
|
|
4236 par = this.get_node(par);
|
|
|
4237 pos = pos === undefined ? 0 : pos;
|
|
|
4238 if(!par) { return false; }
|
|
|
4239 if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {
|
|
|
4240 return this.load_node(par, function () { this.copy_node(obj, par, pos, callback, true, false, origin); });
|
|
|
4241 }
|
|
|
4242
|
|
|
4243 if($.isArray(obj)) {
|
|
|
4244 if(obj.length === 1) {
|
|
|
4245 obj = obj[0];
|
|
|
4246 }
|
|
|
4247 else {
|
|
|
4248 //obj = obj.slice();
|
|
|
4249 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4250 if((tmp = this.copy_node(obj[t1], par, pos, callback, is_loaded, true, origin))) {
|
|
|
4251 par = tmp;
|
|
|
4252 pos = "after";
|
|
|
4253 }
|
|
|
4254 }
|
|
|
4255 this.redraw();
|
|
|
4256 return true;
|
|
|
4257 }
|
|
|
4258 }
|
|
|
4259 obj = obj && obj.id ? obj : this.get_node(obj);
|
|
|
4260 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
4261
|
|
|
4262 old_par = (obj.parent || $.jstree.root).toString();
|
|
|
4263 new_par = (!pos.toString().match(/^(before|after)$/) || par.id === $.jstree.root) ? par : this.get_node(par.parent);
|
|
|
4264 old_ins = origin ? origin : (this._model.data[obj.id] ? this : $.jstree.reference(obj.id));
|
|
|
4265 is_multi = !old_ins || !old_ins._id || (this._id !== old_ins._id);
|
|
|
4266
|
|
|
4267 if(old_ins && old_ins._id) {
|
|
|
4268 obj = old_ins._model.data[obj.id];
|
|
|
4269 }
|
|
|
4270
|
|
|
4271 if(par.id === $.jstree.root) {
|
|
|
4272 if(pos === "before") { pos = "first"; }
|
|
|
4273 if(pos === "after") { pos = "last"; }
|
|
|
4274 }
|
|
|
4275 switch(pos) {
|
|
|
4276 case "before":
|
|
|
4277 pos = $.inArray(par.id, new_par.children);
|
|
|
4278 break;
|
|
|
4279 case "after" :
|
|
|
4280 pos = $.inArray(par.id, new_par.children) + 1;
|
|
|
4281 break;
|
|
|
4282 case "inside":
|
|
|
4283 case "first":
|
|
|
4284 pos = 0;
|
|
|
4285 break;
|
|
|
4286 case "last":
|
|
|
4287 pos = new_par.children.length;
|
|
|
4288 break;
|
|
|
4289 default:
|
|
|
4290 if(!pos) { pos = 0; }
|
|
|
4291 break;
|
|
|
4292 }
|
|
|
4293 if(pos > new_par.children.length) { pos = new_par.children.length; }
|
|
|
4294 if(!this.check("copy_node", obj, new_par, pos, { 'core' : true, 'origin' : origin, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id) })) {
|
|
|
4295 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
4296 return false;
|
|
|
4297 }
|
|
|
4298 node = old_ins ? old_ins.get_json(obj, { no_id : true, no_data : true, no_state : true }) : obj;
|
|
|
4299 if(!node) { return false; }
|
|
|
4300 if(node.id === true) { delete node.id; }
|
|
|
4301 node = this._parse_model_from_json(node, new_par.id, new_par.parents.concat());
|
|
|
4302 if(!node) { return false; }
|
|
|
4303 tmp = this.get_node(node);
|
|
|
4304 if(obj && obj.state && obj.state.loaded === false) { tmp.state.loaded = false; }
|
|
|
4305 dpc = [];
|
|
|
4306 dpc.push(node);
|
|
|
4307 dpc = dpc.concat(tmp.children_d);
|
|
|
4308 this.trigger('model', { "nodes" : dpc, "parent" : new_par.id });
|
|
|
4309
|
|
|
4310 // insert into new parent and up
|
|
|
4311 for(i = 0, j = new_par.parents.length; i < j; i++) {
|
|
|
4312 this._model.data[new_par.parents[i]].children_d = this._model.data[new_par.parents[i]].children_d.concat(dpc);
|
|
|
4313 }
|
|
|
4314 dpc = [];
|
|
|
4315 for(i = 0, j = new_par.children.length; i < j; i++) {
|
|
|
4316 dpc[i >= pos ? i+1 : i] = new_par.children[i];
|
|
|
4317 }
|
|
|
4318 dpc[pos] = tmp.id;
|
|
|
4319 new_par.children = dpc;
|
|
|
4320 new_par.children_d.push(tmp.id);
|
|
|
4321 new_par.children_d = new_par.children_d.concat(tmp.children_d);
|
|
|
4322
|
|
|
4323 if(new_par.id === $.jstree.root) {
|
|
|
4324 this._model.force_full_redraw = true;
|
|
|
4325 }
|
|
|
4326 if(!this._model.force_full_redraw) {
|
|
|
4327 this._node_changed(new_par.id);
|
|
|
4328 }
|
|
|
4329 if(!skip_redraw) {
|
|
|
4330 this.redraw(new_par.id === $.jstree.root);
|
|
|
4331 }
|
|
|
4332 if(callback) { callback.call(this, tmp, new_par, pos); }
|
|
|
4333 /**
|
|
|
4334 * triggered when a node is copied
|
|
|
4335 * @event
|
|
|
4336 * @name copy_node.jstree
|
|
|
4337 * @param {Object} node the copied node
|
|
|
4338 * @param {Object} original the original node
|
|
|
4339 * @param {String} parent the parent's ID
|
|
|
4340 * @param {Number} position the position of the node among the parent's children
|
|
|
4341 * @param {String} old_parent the old parent of the node
|
|
|
4342 * @param {Number} old_position the position of the original node
|
|
|
4343 * @param {Boolean} is_multi do the node and new parent belong to different instances
|
|
|
4344 * @param {jsTree} old_instance the instance the node came from
|
|
|
4345 * @param {jsTree} new_instance the instance of the new parent
|
|
|
4346 */
|
|
|
4347 this.trigger('copy_node', { "node" : tmp, "original" : obj, "parent" : new_par.id, "position" : pos, "old_parent" : old_par, "old_position" : old_ins && old_ins._id && old_par && old_ins._model.data[old_par] && old_ins._model.data[old_par].children ? $.inArray(obj.id, old_ins._model.data[old_par].children) : -1,'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id), 'old_instance' : old_ins, 'new_instance' : this });
|
|
|
4348 return tmp.id;
|
|
|
4349 },
|
|
|
4350 /**
|
|
|
4351 * cut a node (a later call to `paste(obj)` would move the node)
|
|
|
4352 * @name cut(obj)
|
|
|
4353 * @param {mixed} obj multiple objects can be passed using an array
|
|
|
4354 * @trigger cut.jstree
|
|
|
4355 */
|
|
|
4356 cut : function (obj) {
|
|
|
4357 if(!obj) { obj = this._data.core.selected.concat(); }
|
|
|
4358 if(!$.isArray(obj)) { obj = [obj]; }
|
|
|
4359 if(!obj.length) { return false; }
|
|
|
4360 var tmp = [], o, t1, t2;
|
|
|
4361 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4362 o = this.get_node(obj[t1]);
|
|
|
4363 if(o && o.id && o.id !== $.jstree.root) { tmp.push(o); }
|
|
|
4364 }
|
|
|
4365 if(!tmp.length) { return false; }
|
|
|
4366 ccp_node = tmp;
|
|
|
4367 ccp_inst = this;
|
|
|
4368 ccp_mode = 'move_node';
|
|
|
4369 /**
|
|
|
4370 * triggered when nodes are added to the buffer for moving
|
|
|
4371 * @event
|
|
|
4372 * @name cut.jstree
|
|
|
4373 * @param {Array} node
|
|
|
4374 */
|
|
|
4375 this.trigger('cut', { "node" : obj });
|
|
|
4376 },
|
|
|
4377 /**
|
|
|
4378 * copy a node (a later call to `paste(obj)` would copy the node)
|
|
|
4379 * @name copy(obj)
|
|
|
4380 * @param {mixed} obj multiple objects can be passed using an array
|
|
|
4381 * @trigger copy.jstree
|
|
|
4382 */
|
|
|
4383 copy : function (obj) {
|
|
|
4384 if(!obj) { obj = this._data.core.selected.concat(); }
|
|
|
4385 if(!$.isArray(obj)) { obj = [obj]; }
|
|
|
4386 if(!obj.length) { return false; }
|
|
|
4387 var tmp = [], o, t1, t2;
|
|
|
4388 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4389 o = this.get_node(obj[t1]);
|
|
|
4390 if(o && o.id && o.id !== $.jstree.root) { tmp.push(o); }
|
|
|
4391 }
|
|
|
4392 if(!tmp.length) { return false; }
|
|
|
4393 ccp_node = tmp;
|
|
|
4394 ccp_inst = this;
|
|
|
4395 ccp_mode = 'copy_node';
|
|
|
4396 /**
|
|
|
4397 * triggered when nodes are added to the buffer for copying
|
|
|
4398 * @event
|
|
|
4399 * @name copy.jstree
|
|
|
4400 * @param {Array} node
|
|
|
4401 */
|
|
|
4402 this.trigger('copy', { "node" : obj });
|
|
|
4403 },
|
|
|
4404 /**
|
|
|
4405 * get the current buffer (any nodes that are waiting for a paste operation)
|
|
|
4406 * @name get_buffer()
|
|
|
4407 * @return {Object} an object consisting of `mode` ("copy_node" or "move_node"), `node` (an array of objects) and `inst` (the instance)
|
|
|
4408 */
|
|
|
4409 get_buffer : function () {
|
|
|
4410 return { 'mode' : ccp_mode, 'node' : ccp_node, 'inst' : ccp_inst };
|
|
|
4411 },
|
|
|
4412 /**
|
|
|
4413 * check if there is something in the buffer to paste
|
|
|
4414 * @name can_paste()
|
|
|
4415 * @return {Boolean}
|
|
|
4416 */
|
|
|
4417 can_paste : function () {
|
|
|
4418 return ccp_mode !== false && ccp_node !== false; // && ccp_inst._model.data[ccp_node];
|
|
|
4419 },
|
|
|
4420 /**
|
|
|
4421 * copy or move the previously cut or copied nodes to a new parent
|
|
|
4422 * @name paste(obj [, pos])
|
|
|
4423 * @param {mixed} obj the new parent
|
|
|
4424 * @param {mixed} pos the position to insert at (besides integer, "first" and "last" are supported), defaults to integer `0`
|
|
|
4425 * @trigger paste.jstree
|
|
|
4426 */
|
|
|
4427 paste : function (obj, pos) {
|
|
|
4428 obj = this.get_node(obj);
|
|
|
4429 if(!obj || !ccp_mode || !ccp_mode.match(/^(copy_node|move_node)$/) || !ccp_node) { return false; }
|
|
|
4430 if(this[ccp_mode](ccp_node, obj, pos, false, false, false, ccp_inst)) {
|
|
|
4431 /**
|
|
|
4432 * triggered when paste is invoked
|
|
|
4433 * @event
|
|
|
4434 * @name paste.jstree
|
|
|
4435 * @param {String} parent the ID of the receiving node
|
|
|
4436 * @param {Array} node the nodes in the buffer
|
|
|
4437 * @param {String} mode the performed operation - "copy_node" or "move_node"
|
|
|
4438 */
|
|
|
4439 this.trigger('paste', { "parent" : obj.id, "node" : ccp_node, "mode" : ccp_mode });
|
|
|
4440 }
|
|
|
4441 ccp_node = false;
|
|
|
4442 ccp_mode = false;
|
|
|
4443 ccp_inst = false;
|
|
|
4444 },
|
|
|
4445 /**
|
|
|
4446 * clear the buffer of previously copied or cut nodes
|
|
|
4447 * @name clear_buffer()
|
|
|
4448 * @trigger clear_buffer.jstree
|
|
|
4449 */
|
|
|
4450 clear_buffer : function () {
|
|
|
4451 ccp_node = false;
|
|
|
4452 ccp_mode = false;
|
|
|
4453 ccp_inst = false;
|
|
|
4454 /**
|
|
|
4455 * triggered when the copy / cut buffer is cleared
|
|
|
4456 * @event
|
|
|
4457 * @name clear_buffer.jstree
|
|
|
4458 */
|
|
|
4459 this.trigger('clear_buffer');
|
|
|
4460 },
|
|
|
4461 /**
|
|
|
4462 * put a node in edit mode (input field to rename the node)
|
|
|
4463 * @name edit(obj [, default_text, callback])
|
|
|
4464 * @param {mixed} obj
|
|
|
4465 * @param {String} default_text the text to populate the input with (if omitted or set to a non-string value the node's text value is used)
|
|
|
4466 * @param {Function} callback a function to be called once the text box is blurred, it is called in the instance's scope and receives the node, a status parameter (true if the rename is successful, false otherwise) and a boolean indicating if the user cancelled the edit. You can access the node's title using .text
|
|
|
4467 */
|
|
|
4468 edit : function (obj, default_text, callback) {
|
|
|
4469 var rtl, w, a, s, t, h1, h2, fn, tmp, cancel = false;
|
|
|
4470 obj = this.get_node(obj);
|
|
|
4471 if(!obj) { return false; }
|
|
|
4472 if(!this.check("edit", obj, this.get_parent(obj))) {
|
|
|
4473 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
4474 return false;
|
|
|
4475 }
|
|
|
4476 tmp = obj;
|
|
|
4477 default_text = typeof default_text === 'string' ? default_text : obj.text;
|
|
|
4478 this.set_text(obj, "");
|
|
|
4479 obj = this._open_to(obj);
|
|
|
4480 tmp.text = default_text;
|
|
|
4481
|
|
|
4482 rtl = this._data.core.rtl;
|
|
|
4483 w = this.element.width();
|
|
|
4484 this._data.core.focused = tmp.id;
|
|
|
4485 a = obj.children('.jstree-anchor').focus();
|
|
|
4486 s = $('<span>');
|
|
|
4487 /*!
|
|
|
4488 oi = obj.children("i:visible"),
|
|
|
4489 ai = a.children("i:visible"),
|
|
|
4490 w1 = oi.width() * oi.length,
|
|
|
4491 w2 = ai.width() * ai.length,
|
|
|
4492 */
|
|
|
4493 t = default_text;
|
|
|
4494 h1 = $("<"+"div />", { css : { "position" : "absolute", "top" : "-200px", "left" : (rtl ? "0px" : "-1000px"), "visibility" : "hidden" } }).appendTo("body");
|
|
|
4495 h2 = $("<"+"input />", {
|
|
|
4496 "value" : t,
|
|
|
4497 "class" : "jstree-rename-input",
|
|
|
4498 // "size" : t.length,
|
|
|
4499 "css" : {
|
|
|
4500 "padding" : "0",
|
|
|
4501 "border" : "1px solid silver",
|
|
|
4502 "box-sizing" : "border-box",
|
|
|
4503 "display" : "inline-block",
|
|
|
4504 "height" : (this._data.core.li_height) + "px",
|
|
|
4505 "lineHeight" : (this._data.core.li_height) + "px",
|
|
|
4506 "width" : "150px" // will be set a bit further down
|
|
|
4507 },
|
|
|
4508 "blur" : $.proxy(function (e) {
|
|
|
4509 e.stopImmediatePropagation();
|
|
|
4510 e.preventDefault();
|
|
|
4511 var i = s.children(".jstree-rename-input"),
|
|
|
4512 v = i.val(),
|
|
|
4513 f = this.settings.core.force_text,
|
|
|
4514 nv;
|
|
|
4515 if(v === "") { v = t; }
|
|
|
4516 h1.remove();
|
|
|
4517 s.replaceWith(a);
|
|
|
4518 s.remove();
|
|
|
4519 t = f ? t : $('<div></div>').append($.parseHTML(t)).html();
|
|
|
4520 this.set_text(obj, t);
|
|
|
4521 nv = !!this.rename_node(obj, f ? $('<div></div>').text(v).text() : $('<div></div>').append($.parseHTML(v)).html());
|
|
|
4522 if(!nv) {
|
|
|
4523 this.set_text(obj, t); // move this up? and fix #483
|
|
|
4524 }
|
|
|
4525 this._data.core.focused = tmp.id;
|
|
|
4526 setTimeout($.proxy(function () {
|
|
|
4527 var node = this.get_node(tmp.id, true);
|
|
|
4528 if(node.length) {
|
|
|
4529 this._data.core.focused = tmp.id;
|
|
|
4530 node.children('.jstree-anchor').focus();
|
|
|
4531 }
|
|
|
4532 }, this), 0);
|
|
|
4533 if(callback) {
|
|
|
4534 callback.call(this, tmp, nv, cancel);
|
|
|
4535 }
|
|
|
4536 h2 = null;
|
|
|
4537 }, this),
|
|
|
4538 "keydown" : function (e) {
|
|
|
4539 var key = e.which;
|
|
|
4540 if(key === 27) {
|
|
|
4541 cancel = true;
|
|
|
4542 this.value = t;
|
|
|
4543 }
|
|
|
4544 if(key === 27 || key === 13 || key === 37 || key === 38 || key === 39 || key === 40 || key === 32) {
|
|
|
4545 e.stopImmediatePropagation();
|
|
|
4546 }
|
|
|
4547 if(key === 27 || key === 13) {
|
|
|
4548 e.preventDefault();
|
|
|
4549 this.blur();
|
|
|
4550 }
|
|
|
4551 },
|
|
|
4552 "click" : function (e) { e.stopImmediatePropagation(); },
|
|
|
4553 "mousedown" : function (e) { e.stopImmediatePropagation(); },
|
|
|
4554 "keyup" : function (e) {
|
|
|
4555 h2.width(Math.min(h1.text("pW" + this.value).width(),w));
|
|
|
4556 },
|
|
|
4557 "keypress" : function(e) {
|
|
|
4558 if(e.which === 13) { return false; }
|
|
|
4559 }
|
|
|
4560 });
|
|
|
4561 fn = {
|
|
|
4562 fontFamily : a.css('fontFamily') || '',
|
|
|
4563 fontSize : a.css('fontSize') || '',
|
|
|
4564 fontWeight : a.css('fontWeight') || '',
|
|
|
4565 fontStyle : a.css('fontStyle') || '',
|
|
|
4566 fontStretch : a.css('fontStretch') || '',
|
|
|
4567 fontVariant : a.css('fontVariant') || '',
|
|
|
4568 letterSpacing : a.css('letterSpacing') || '',
|
|
|
4569 wordSpacing : a.css('wordSpacing') || ''
|
|
|
4570 };
|
|
|
4571 s.attr('class', a.attr('class')).append(a.contents().clone()).append(h2);
|
|
|
4572 a.replaceWith(s);
|
|
|
4573 h1.css(fn);
|
|
|
4574 h2.css(fn).width(Math.min(h1.text("pW" + h2[0].value).width(),w))[0].select();
|
|
|
4575 $(document).one('mousedown.jstree touchstart.jstree dnd_start.vakata', function (e) {
|
|
|
4576 if (h2 && e.target !== h2) {
|
|
|
4577 $(h2).blur();
|
|
|
4578 }
|
|
|
4579 });
|
|
|
4580 },
|
|
|
4581
|
|
|
4582
|
|
|
4583 /**
|
|
|
4584 * changes the theme
|
|
|
4585 * @name set_theme(theme_name [, theme_url])
|
|
|
4586 * @param {String} theme_name the name of the new theme to apply
|
|
|
4587 * @param {mixed} theme_url the location of the CSS file for this theme. Omit or set to `false` if you manually included the file. Set to `true` to autoload from the `core.themes.dir` directory.
|
|
|
4588 * @trigger set_theme.jstree
|
|
|
4589 */
|
|
|
4590 set_theme : function (theme_name, theme_url) {
|
|
|
4591 if(!theme_name) { return false; }
|
|
|
4592 if(theme_url === true) {
|
|
|
4593 var dir = this.settings.core.themes.dir;
|
|
|
4594 if(!dir) { dir = $.jstree.path + '/themes'; }
|
|
|
4595 theme_url = dir + '/' + theme_name + '/style.css';
|
|
|
4596 }
|
|
|
4597 if(theme_url && $.inArray(theme_url, themes_loaded) === -1) {
|
|
|
4598 $('head').append('<'+'link rel="stylesheet" href="' + theme_url + '" type="text/css" />');
|
|
|
4599 themes_loaded.push(theme_url);
|
|
|
4600 }
|
|
|
4601 if(this._data.core.themes.name) {
|
|
|
4602 this.element.removeClass('jstree-' + this._data.core.themes.name);
|
|
|
4603 }
|
|
|
4604 this._data.core.themes.name = theme_name;
|
|
|
4605 this.element.addClass('jstree-' + theme_name);
|
|
|
4606 this.element[this.settings.core.themes.responsive ? 'addClass' : 'removeClass' ]('jstree-' + theme_name + '-responsive');
|
|
|
4607 /**
|
|
|
4608 * triggered when a theme is set
|
|
|
4609 * @event
|
|
|
4610 * @name set_theme.jstree
|
|
|
4611 * @param {String} theme the new theme
|
|
|
4612 */
|
|
|
4613 this.trigger('set_theme', { 'theme' : theme_name });
|
|
|
4614 },
|
|
|
4615 /**
|
|
|
4616 * gets the name of the currently applied theme name
|
|
|
4617 * @name get_theme()
|
|
|
4618 * @return {String}
|
|
|
4619 */
|
|
|
4620 get_theme : function () { return this._data.core.themes.name; },
|
|
|
4621 /**
|
|
|
4622 * changes the theme variant (if the theme has variants)
|
|
|
4623 * @name set_theme_variant(variant_name)
|
|
|
4624 * @param {String|Boolean} variant_name the variant to apply (if `false` is used the current variant is removed)
|
|
|
4625 */
|
|
|
4626 set_theme_variant : function (variant_name) {
|
|
|
4627 if(this._data.core.themes.variant) {
|
|
|
4628 this.element.removeClass('jstree-' + this._data.core.themes.name + '-' + this._data.core.themes.variant);
|
|
|
4629 }
|
|
|
4630 this._data.core.themes.variant = variant_name;
|
|
|
4631 if(variant_name) {
|
|
|
4632 this.element.addClass('jstree-' + this._data.core.themes.name + '-' + this._data.core.themes.variant);
|
|
|
4633 }
|
|
|
4634 },
|
|
|
4635 /**
|
|
|
4636 * gets the name of the currently applied theme variant
|
|
|
4637 * @name get_theme()
|
|
|
4638 * @return {String}
|
|
|
4639 */
|
|
|
4640 get_theme_variant : function () { return this._data.core.themes.variant; },
|
|
|
4641 /**
|
|
|
4642 * shows a striped background on the container (if the theme supports it)
|
|
|
4643 * @name show_stripes()
|
|
|
4644 */
|
|
|
4645 show_stripes : function () {
|
|
|
4646 this._data.core.themes.stripes = true;
|
|
|
4647 this.get_container_ul().addClass("jstree-striped");
|
|
|
4648 /**
|
|
|
4649 * triggered when stripes are shown
|
|
|
4650 * @event
|
|
|
4651 * @name show_stripes.jstree
|
|
|
4652 */
|
|
|
4653 this.trigger('show_stripes');
|
|
|
4654 },
|
|
|
4655 /**
|
|
|
4656 * hides the striped background on the container
|
|
|
4657 * @name hide_stripes()
|
|
|
4658 */
|
|
|
4659 hide_stripes : function () {
|
|
|
4660 this._data.core.themes.stripes = false;
|
|
|
4661 this.get_container_ul().removeClass("jstree-striped");
|
|
|
4662 /**
|
|
|
4663 * triggered when stripes are hidden
|
|
|
4664 * @event
|
|
|
4665 * @name hide_stripes.jstree
|
|
|
4666 */
|
|
|
4667 this.trigger('hide_stripes');
|
|
|
4668 },
|
|
|
4669 /**
|
|
|
4670 * toggles the striped background on the container
|
|
|
4671 * @name toggle_stripes()
|
|
|
4672 */
|
|
|
4673 toggle_stripes : function () { if(this._data.core.themes.stripes) { this.hide_stripes(); } else { this.show_stripes(); } },
|
|
|
4674 /**
|
|
|
4675 * shows the connecting dots (if the theme supports it)
|
|
|
4676 * @name show_dots()
|
|
|
4677 */
|
|
|
4678 show_dots : function () {
|
|
|
4679 this._data.core.themes.dots = true;
|
|
|
4680 this.get_container_ul().removeClass("jstree-no-dots");
|
|
|
4681 /**
|
|
|
4682 * triggered when dots are shown
|
|
|
4683 * @event
|
|
|
4684 * @name show_dots.jstree
|
|
|
4685 */
|
|
|
4686 this.trigger('show_dots');
|
|
|
4687 },
|
|
|
4688 /**
|
|
|
4689 * hides the connecting dots
|
|
|
4690 * @name hide_dots()
|
|
|
4691 */
|
|
|
4692 hide_dots : function () {
|
|
|
4693 this._data.core.themes.dots = false;
|
|
|
4694 this.get_container_ul().addClass("jstree-no-dots");
|
|
|
4695 /**
|
|
|
4696 * triggered when dots are hidden
|
|
|
4697 * @event
|
|
|
4698 * @name hide_dots.jstree
|
|
|
4699 */
|
|
|
4700 this.trigger('hide_dots');
|
|
|
4701 },
|
|
|
4702 /**
|
|
|
4703 * toggles the connecting dots
|
|
|
4704 * @name toggle_dots()
|
|
|
4705 */
|
|
|
4706 toggle_dots : function () { if(this._data.core.themes.dots) { this.hide_dots(); } else { this.show_dots(); } },
|
|
|
4707 /**
|
|
|
4708 * show the node icons
|
|
|
4709 * @name show_icons()
|
|
|
4710 */
|
|
|
4711 show_icons : function () {
|
|
|
4712 this._data.core.themes.icons = true;
|
|
|
4713 this.get_container_ul().removeClass("jstree-no-icons");
|
|
|
4714 /**
|
|
|
4715 * triggered when icons are shown
|
|
|
4716 * @event
|
|
|
4717 * @name show_icons.jstree
|
|
|
4718 */
|
|
|
4719 this.trigger('show_icons');
|
|
|
4720 },
|
|
|
4721 /**
|
|
|
4722 * hide the node icons
|
|
|
4723 * @name hide_icons()
|
|
|
4724 */
|
|
|
4725 hide_icons : function () {
|
|
|
4726 this._data.core.themes.icons = false;
|
|
|
4727 this.get_container_ul().addClass("jstree-no-icons");
|
|
|
4728 /**
|
|
|
4729 * triggered when icons are hidden
|
|
|
4730 * @event
|
|
|
4731 * @name hide_icons.jstree
|
|
|
4732 */
|
|
|
4733 this.trigger('hide_icons');
|
|
|
4734 },
|
|
|
4735 /**
|
|
|
4736 * toggle the node icons
|
|
|
4737 * @name toggle_icons()
|
|
|
4738 */
|
|
|
4739 toggle_icons : function () { if(this._data.core.themes.icons) { this.hide_icons(); } else { this.show_icons(); } },
|
|
|
4740 /**
|
|
|
4741 * show the node ellipsis
|
|
|
4742 * @name show_icons()
|
|
|
4743 */
|
|
|
4744 show_ellipsis : function () {
|
|
|
4745 this._data.core.themes.ellipsis = true;
|
|
|
4746 this.get_container_ul().addClass("jstree-ellipsis");
|
|
|
4747 /**
|
|
|
4748 * triggered when ellisis is shown
|
|
|
4749 * @event
|
|
|
4750 * @name show_ellipsis.jstree
|
|
|
4751 */
|
|
|
4752 this.trigger('show_ellipsis');
|
|
|
4753 },
|
|
|
4754 /**
|
|
|
4755 * hide the node ellipsis
|
|
|
4756 * @name hide_ellipsis()
|
|
|
4757 */
|
|
|
4758 hide_ellipsis : function () {
|
|
|
4759 this._data.core.themes.ellipsis = false;
|
|
|
4760 this.get_container_ul().removeClass("jstree-ellipsis");
|
|
|
4761 /**
|
|
|
4762 * triggered when ellisis is hidden
|
|
|
4763 * @event
|
|
|
4764 * @name hide_ellipsis.jstree
|
|
|
4765 */
|
|
|
4766 this.trigger('hide_ellipsis');
|
|
|
4767 },
|
|
|
4768 /**
|
|
|
4769 * toggle the node ellipsis
|
|
|
4770 * @name toggle_icons()
|
|
|
4771 */
|
|
|
4772 toggle_ellipsis : function () { if(this._data.core.themes.ellipsis) { this.hide_ellipsis(); } else { this.show_ellipsis(); } },
|
|
|
4773 /**
|
|
|
4774 * set the node icon for a node
|
|
|
4775 * @name set_icon(obj, icon)
|
|
|
4776 * @param {mixed} obj
|
|
|
4777 * @param {String} icon the new icon - can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class
|
|
|
4778 */
|
|
|
4779 set_icon : function (obj, icon) {
|
|
|
4780 var t1, t2, dom, old;
|
|
|
4781 if($.isArray(obj)) {
|
|
|
4782 obj = obj.slice();
|
|
|
4783 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4784 this.set_icon(obj[t1], icon);
|
|
|
4785 }
|
|
|
4786 return true;
|
|
|
4787 }
|
|
|
4788 obj = this.get_node(obj);
|
|
|
4789 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
4790 old = obj.icon;
|
|
|
4791 obj.icon = icon === true || icon === null || icon === undefined || icon === '' ? true : icon;
|
|
|
4792 dom = this.get_node(obj, true).children(".jstree-anchor").children(".jstree-themeicon");
|
|
|
4793 if(icon === false) {
|
|
|
4794 dom.removeClass('jstree-themeicon-custom ' + old).css("background","").removeAttr("rel");
|
|
|
4795 this.hide_icon(obj);
|
|
|
4796 }
|
|
|
4797 else if(icon === true || icon === null || icon === undefined || icon === '') {
|
|
|
4798 dom.removeClass('jstree-themeicon-custom ' + old).css("background","").removeAttr("rel");
|
|
|
4799 if(old === false) { this.show_icon(obj); }
|
|
|
4800 }
|
|
|
4801 else if(icon.indexOf("/") === -1 && icon.indexOf(".") === -1) {
|
|
|
4802 dom.removeClass(old).css("background","");
|
|
|
4803 dom.addClass(icon + ' jstree-themeicon-custom').attr("rel",icon);
|
|
|
4804 if(old === false) { this.show_icon(obj); }
|
|
|
4805 }
|
|
|
4806 else {
|
|
|
4807 dom.removeClass(old).css("background","");
|
|
|
4808 dom.addClass('jstree-themeicon-custom').css("background", "url('" + icon + "') center center no-repeat").attr("rel",icon);
|
|
|
4809 if(old === false) { this.show_icon(obj); }
|
|
|
4810 }
|
|
|
4811 return true;
|
|
|
4812 },
|
|
|
4813 /**
|
|
|
4814 * get the node icon for a node
|
|
|
4815 * @name get_icon(obj)
|
|
|
4816 * @param {mixed} obj
|
|
|
4817 * @return {String}
|
|
|
4818 */
|
|
|
4819 get_icon : function (obj) {
|
|
|
4820 obj = this.get_node(obj);
|
|
|
4821 return (!obj || obj.id === $.jstree.root) ? false : obj.icon;
|
|
|
4822 },
|
|
|
4823 /**
|
|
|
4824 * hide the icon on an individual node
|
|
|
4825 * @name hide_icon(obj)
|
|
|
4826 * @param {mixed} obj
|
|
|
4827 */
|
|
|
4828 hide_icon : function (obj) {
|
|
|
4829 var t1, t2;
|
|
|
4830 if($.isArray(obj)) {
|
|
|
4831 obj = obj.slice();
|
|
|
4832 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4833 this.hide_icon(obj[t1]);
|
|
|
4834 }
|
|
|
4835 return true;
|
|
|
4836 }
|
|
|
4837 obj = this.get_node(obj);
|
|
|
4838 if(!obj || obj === $.jstree.root) { return false; }
|
|
|
4839 obj.icon = false;
|
|
|
4840 this.get_node(obj, true).children(".jstree-anchor").children(".jstree-themeicon").addClass('jstree-themeicon-hidden');
|
|
|
4841 return true;
|
|
|
4842 },
|
|
|
4843 /**
|
|
|
4844 * show the icon on an individual node
|
|
|
4845 * @name show_icon(obj)
|
|
|
4846 * @param {mixed} obj
|
|
|
4847 */
|
|
|
4848 show_icon : function (obj) {
|
|
|
4849 var t1, t2, dom;
|
|
|
4850 if($.isArray(obj)) {
|
|
|
4851 obj = obj.slice();
|
|
|
4852 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
4853 this.show_icon(obj[t1]);
|
|
|
4854 }
|
|
|
4855 return true;
|
|
|
4856 }
|
|
|
4857 obj = this.get_node(obj);
|
|
|
4858 if(!obj || obj === $.jstree.root) { return false; }
|
|
|
4859 dom = this.get_node(obj, true);
|
|
|
4860 obj.icon = dom.length ? dom.children(".jstree-anchor").children(".jstree-themeicon").attr('rel') : true;
|
|
|
4861 if(!obj.icon) { obj.icon = true; }
|
|
|
4862 dom.children(".jstree-anchor").children(".jstree-themeicon").removeClass('jstree-themeicon-hidden');
|
|
|
4863 return true;
|
|
|
4864 }
|
|
|
4865 };
|
|
|
4866
|
|
|
4867 // helpers
|
|
|
4868 $.vakata = {};
|
|
|
4869 // collect attributes
|
|
|
4870 $.vakata.attributes = function(node, with_values) {
|
|
|
4871 node = $(node)[0];
|
|
|
4872 var attr = with_values ? {} : [];
|
|
|
4873 if(node && node.attributes) {
|
|
|
4874 $.each(node.attributes, function (i, v) {
|
|
|
4875 if($.inArray(v.name.toLowerCase(),['style','contenteditable','hasfocus','tabindex']) !== -1) { return; }
|
|
|
4876 if(v.value !== null && $.trim(v.value) !== '') {
|
|
|
4877 if(with_values) { attr[v.name] = v.value; }
|
|
|
4878 else { attr.push(v.name); }
|
|
|
4879 }
|
|
|
4880 });
|
|
|
4881 }
|
|
|
4882 return attr;
|
|
|
4883 };
|
|
|
4884 $.vakata.array_unique = function(array) {
|
|
|
4885 var a = [], i, j, l, o = {};
|
|
|
4886 for(i = 0, l = array.length; i < l; i++) {
|
|
|
4887 if(o[array[i]] === undefined) {
|
|
|
4888 a.push(array[i]);
|
|
|
4889 o[array[i]] = true;
|
|
|
4890 }
|
|
|
4891 }
|
|
|
4892 return a;
|
|
|
4893 };
|
|
|
4894 // remove item from array
|
|
|
4895 $.vakata.array_remove = function(array, from) {
|
|
|
4896 array.splice(from, 1);
|
|
|
4897 return array;
|
|
|
4898 //var rest = array.slice((to || from) + 1 || array.length);
|
|
|
4899 //array.length = from < 0 ? array.length + from : from;
|
|
|
4900 //array.push.apply(array, rest);
|
|
|
4901 //return array;
|
|
|
4902 };
|
|
|
4903 // remove item from array
|
|
|
4904 $.vakata.array_remove_item = function(array, item) {
|
|
|
4905 var tmp = $.inArray(item, array);
|
|
|
4906 return tmp !== -1 ? $.vakata.array_remove(array, tmp) : array;
|
|
|
4907 };
|
|
|
4908 $.vakata.array_filter = function(c,a,b,d,e) {
|
|
|
4909 if (c.filter) {
|
|
|
4910 return c.filter(a, b);
|
|
|
4911 }
|
|
|
4912 d=[];
|
|
|
4913 for (e in c) {
|
|
|
4914 if (~~e+''===e+'' && e>=0 && a.call(b,c[e],+e,c)) {
|
|
|
4915 d.push(c[e]);
|
|
|
4916 }
|
|
|
4917 }
|
|
|
4918 return d;
|
|
|
4919 };
|
|
|
4920
|
|
|
4921
|
|
|
4922 /**
|
|
|
4923 * ### Changed plugin
|
|
|
4924 *
|
|
|
4925 * This plugin adds more information to the `changed.jstree` event. The new data is contained in the `changed` event data property, and contains a lists of `selected` and `deselected` nodes.
|
|
|
4926 */
|
|
|
4927
|
|
|
4928 $.jstree.plugins.changed = function (options, parent) {
|
|
|
4929 var last = [];
|
|
|
4930 this.trigger = function (ev, data) {
|
|
|
4931 var i, j;
|
|
|
4932 if(!data) {
|
|
|
4933 data = {};
|
|
|
4934 }
|
|
|
4935 if(ev.replace('.jstree','') === 'changed') {
|
|
|
4936 data.changed = { selected : [], deselected : [] };
|
|
|
4937 var tmp = {};
|
|
|
4938 for(i = 0, j = last.length; i < j; i++) {
|
|
|
4939 tmp[last[i]] = 1;
|
|
|
4940 }
|
|
|
4941 for(i = 0, j = data.selected.length; i < j; i++) {
|
|
|
4942 if(!tmp[data.selected[i]]) {
|
|
|
4943 data.changed.selected.push(data.selected[i]);
|
|
|
4944 }
|
|
|
4945 else {
|
|
|
4946 tmp[data.selected[i]] = 2;
|
|
|
4947 }
|
|
|
4948 }
|
|
|
4949 for(i = 0, j = last.length; i < j; i++) {
|
|
|
4950 if(tmp[last[i]] === 1) {
|
|
|
4951 data.changed.deselected.push(last[i]);
|
|
|
4952 }
|
|
|
4953 }
|
|
|
4954 last = data.selected.slice();
|
|
|
4955 }
|
|
|
4956 /**
|
|
|
4957 * triggered when selection changes (the "changed" plugin enhances the original event with more data)
|
|
|
4958 * @event
|
|
|
4959 * @name changed.jstree
|
|
|
4960 * @param {Object} node
|
|
|
4961 * @param {Object} action the action that caused the selection to change
|
|
|
4962 * @param {Array} selected the current selection
|
|
|
4963 * @param {Object} changed an object containing two properties `selected` and `deselected` - both arrays of node IDs, which were selected or deselected since the last changed event
|
|
|
4964 * @param {Object} event the event (if any) that triggered this changed event
|
|
|
4965 * @plugin changed
|
|
|
4966 */
|
|
|
4967 parent.trigger.call(this, ev, data);
|
|
|
4968 };
|
|
|
4969 this.refresh = function (skip_loading, forget_state) {
|
|
|
4970 last = [];
|
|
|
4971 return parent.refresh.apply(this, arguments);
|
|
|
4972 };
|
|
|
4973 };
|
|
|
4974
|
|
|
4975 /**
|
|
|
4976 * ### Checkbox plugin
|
|
|
4977 *
|
|
|
4978 * This plugin renders checkbox icons in front of each node, making multiple selection much easier.
|
|
|
4979 * It also supports tri-state behavior, meaning that if a node has a few of its children checked it will be rendered as undetermined, and state will be propagated up.
|
|
|
4980 */
|
|
|
4981
|
|
|
4982 var _i = document.createElement('I');
|
|
|
4983 _i.className = 'jstree-icon jstree-checkbox';
|
|
|
4984 _i.setAttribute('role', 'presentation');
|
|
|
4985 /**
|
|
|
4986 * stores all defaults for the checkbox plugin
|
|
|
4987 * @name $.jstree.defaults.checkbox
|
|
|
4988 * @plugin checkbox
|
|
|
4989 */
|
|
|
4990 $.jstree.defaults.checkbox = {
|
|
|
4991 /**
|
|
|
4992 * a boolean indicating if checkboxes should be visible (can be changed at a later time using `show_checkboxes()` and `hide_checkboxes`). Defaults to `true`.
|
|
|
4993 * @name $.jstree.defaults.checkbox.visible
|
|
|
4994 * @plugin checkbox
|
|
|
4995 */
|
|
|
4996 visible : true,
|
|
|
4997 /**
|
|
|
4998 * a boolean indicating if checkboxes should cascade down and have an undetermined state. Defaults to `true`.
|
|
|
4999 * @name $.jstree.defaults.checkbox.three_state
|
|
|
5000 * @plugin checkbox
|
|
|
5001 */
|
|
|
5002 three_state : true,
|
|
|
5003 /**
|
|
|
5004 * a boolean indicating if clicking anywhere on the node should act as clicking on the checkbox. Defaults to `true`.
|
|
|
5005 * @name $.jstree.defaults.checkbox.whole_node
|
|
|
5006 * @plugin checkbox
|
|
|
5007 */
|
|
|
5008 whole_node : true,
|
|
|
5009 /**
|
|
|
5010 * a boolean indicating if the selected style of a node should be kept, or removed. Defaults to `true`.
|
|
|
5011 * @name $.jstree.defaults.checkbox.keep_selected_style
|
|
|
5012 * @plugin checkbox
|
|
|
5013 */
|
|
|
5014 keep_selected_style : true,
|
|
|
5015 /**
|
|
|
5016 * This setting controls how cascading and undetermined nodes are applied.
|
|
|
5017 * If 'up' is in the string - cascading up is enabled, if 'down' is in the string - cascading down is enabled, if 'undetermined' is in the string - undetermined nodes will be used.
|
|
|
5018 * If `three_state` is set to `true` this setting is automatically set to 'up+down+undetermined'. Defaults to ''.
|
|
|
5019 * @name $.jstree.defaults.checkbox.cascade
|
|
|
5020 * @plugin checkbox
|
|
|
5021 */
|
|
|
5022 cascade : '',
|
|
|
5023 /**
|
|
|
5024 * This setting controls if checkbox are bound to the general tree selection or to an internal array maintained by the checkbox plugin. Defaults to `true`, only set to `false` if you know exactly what you are doing.
|
|
|
5025 * @name $.jstree.defaults.checkbox.tie_selection
|
|
|
5026 * @plugin checkbox
|
|
|
5027 */
|
|
|
5028 tie_selection : true,
|
|
|
5029
|
|
|
5030 /**
|
|
|
5031 * This setting controls if cascading down affects disabled checkboxes
|
|
|
5032 * @name $.jstree.defaults.checkbox.cascade_to_disabled
|
|
|
5033 * @plugin checkbox
|
|
|
5034 */
|
|
|
5035 cascade_to_disabled : true,
|
|
|
5036
|
|
|
5037 /**
|
|
|
5038 * This setting controls if cascading down affects hidden checkboxes
|
|
|
5039 * @name $.jstree.defaults.checkbox.cascade_to_hidden
|
|
|
5040 * @plugin checkbox
|
|
|
5041 */
|
|
|
5042 cascade_to_hidden : true
|
|
|
5043 };
|
|
|
5044 $.jstree.plugins.checkbox = function (options, parent) {
|
|
|
5045 this.bind = function () {
|
|
|
5046 parent.bind.call(this);
|
|
|
5047 this._data.checkbox.uto = false;
|
|
|
5048 this._data.checkbox.selected = [];
|
|
|
5049 if(this.settings.checkbox.three_state) {
|
|
|
5050 this.settings.checkbox.cascade = 'up+down+undetermined';
|
|
|
5051 }
|
|
|
5052 this.element
|
|
|
5053 .on("init.jstree", $.proxy(function () {
|
|
|
5054 this._data.checkbox.visible = this.settings.checkbox.visible;
|
|
|
5055 if(!this.settings.checkbox.keep_selected_style) {
|
|
|
5056 this.element.addClass('jstree-checkbox-no-clicked');
|
|
|
5057 }
|
|
|
5058 if(this.settings.checkbox.tie_selection) {
|
|
|
5059 this.element.addClass('jstree-checkbox-selection');
|
|
|
5060 }
|
|
|
5061 }, this))
|
|
|
5062 .on("loading.jstree", $.proxy(function () {
|
|
|
5063 this[ this._data.checkbox.visible ? 'show_checkboxes' : 'hide_checkboxes' ]();
|
|
|
5064 }, this));
|
|
|
5065 if(this.settings.checkbox.cascade.indexOf('undetermined') !== -1) {
|
|
|
5066 this.element
|
|
|
5067 .on('changed.jstree uncheck_node.jstree check_node.jstree uncheck_all.jstree check_all.jstree move_node.jstree copy_node.jstree redraw.jstree open_node.jstree', $.proxy(function () {
|
|
|
5068 // only if undetermined is in setting
|
|
|
5069 if(this._data.checkbox.uto) { clearTimeout(this._data.checkbox.uto); }
|
|
|
5070 this._data.checkbox.uto = setTimeout($.proxy(this._undetermined, this), 50);
|
|
|
5071 }, this));
|
|
|
5072 }
|
|
|
5073 if(!this.settings.checkbox.tie_selection) {
|
|
|
5074 this.element
|
|
|
5075 .on('model.jstree', $.proxy(function (e, data) {
|
|
|
5076 var m = this._model.data,
|
|
|
5077 p = m[data.parent],
|
|
|
5078 dpc = data.nodes,
|
|
|
5079 i, j;
|
|
|
5080 for(i = 0, j = dpc.length; i < j; i++) {
|
|
|
5081 m[dpc[i]].state.checked = m[dpc[i]].state.checked || (m[dpc[i]].original && m[dpc[i]].original.state && m[dpc[i]].original.state.checked);
|
|
|
5082 if(m[dpc[i]].state.checked) {
|
|
|
5083 this._data.checkbox.selected.push(dpc[i]);
|
|
|
5084 }
|
|
|
5085 }
|
|
|
5086 }, this));
|
|
|
5087 }
|
|
|
5088 if(this.settings.checkbox.cascade.indexOf('up') !== -1 || this.settings.checkbox.cascade.indexOf('down') !== -1) {
|
|
|
5089 this.element
|
|
|
5090 .on('model.jstree', $.proxy(function (e, data) {
|
|
|
5091 var m = this._model.data,
|
|
|
5092 p = m[data.parent],
|
|
|
5093 dpc = data.nodes,
|
|
|
5094 chd = [],
|
|
|
5095 c, i, j, k, l, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection;
|
|
|
5096
|
|
|
5097 if(s.indexOf('down') !== -1) {
|
|
|
5098 // apply down
|
|
|
5099 if(p.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5100 for(i = 0, j = dpc.length; i < j; i++) {
|
|
|
5101 m[dpc[i]].state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5102 }
|
|
|
5103
|
|
|
5104 this._data[ t ? 'core' : 'checkbox' ].selected = this._data[ t ? 'core' : 'checkbox' ].selected.concat(dpc);
|
|
|
5105 }
|
|
|
5106 else {
|
|
|
5107 for(i = 0, j = dpc.length; i < j; i++) {
|
|
|
5108 if(m[dpc[i]].state[ t ? 'selected' : 'checked' ]) {
|
|
|
5109 for(k = 0, l = m[dpc[i]].children_d.length; k < l; k++) {
|
|
|
5110 m[m[dpc[i]].children_d[k]].state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5111 }
|
|
|
5112 this._data[ t ? 'core' : 'checkbox' ].selected = this._data[ t ? 'core' : 'checkbox' ].selected.concat(m[dpc[i]].children_d);
|
|
|
5113 }
|
|
|
5114 }
|
|
|
5115 }
|
|
|
5116 }
|
|
|
5117
|
|
|
5118 if(s.indexOf('up') !== -1) {
|
|
|
5119 // apply up
|
|
|
5120 for(i = 0, j = p.children_d.length; i < j; i++) {
|
|
|
5121 if(!m[p.children_d[i]].children.length) {
|
|
|
5122 chd.push(m[p.children_d[i]].parent);
|
|
|
5123 }
|
|
|
5124 }
|
|
|
5125 chd = $.vakata.array_unique(chd);
|
|
|
5126 for(k = 0, l = chd.length; k < l; k++) {
|
|
|
5127 p = m[chd[k]];
|
|
|
5128 while(p && p.id !== $.jstree.root) {
|
|
|
5129 c = 0;
|
|
|
5130 for(i = 0, j = p.children.length; i < j; i++) {
|
|
|
5131 c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];
|
|
|
5132 }
|
|
|
5133 if(c === j) {
|
|
|
5134 p.state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5135 this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);
|
|
|
5136 tmp = this.get_node(p, true);
|
|
|
5137 if(tmp && tmp.length) {
|
|
|
5138 tmp.attr('aria-selected', true).children('.jstree-anchor').addClass( t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5139 }
|
|
|
5140 }
|
|
|
5141 else {
|
|
|
5142 break;
|
|
|
5143 }
|
|
|
5144 p = this.get_node(p.parent);
|
|
|
5145 }
|
|
|
5146 }
|
|
|
5147 }
|
|
|
5148
|
|
|
5149 this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_unique(this._data[ t ? 'core' : 'checkbox' ].selected);
|
|
|
5150 }, this))
|
|
|
5151 .on(this.settings.checkbox.tie_selection ? 'select_node.jstree' : 'check_node.jstree', $.proxy(function (e, data) {
|
|
|
5152 var self = this,
|
|
|
5153 obj = data.node,
|
|
|
5154 m = this._model.data,
|
|
|
5155 par = this.get_node(obj.parent),
|
|
|
5156 i, j, c, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection,
|
|
|
5157 sel = {}, cur = this._data[ t ? 'core' : 'checkbox' ].selected;
|
|
|
5158
|
|
|
5159 for (i = 0, j = cur.length; i < j; i++) {
|
|
|
5160 sel[cur[i]] = true;
|
|
|
5161 }
|
|
|
5162
|
|
|
5163 // apply down
|
|
|
5164 if(s.indexOf('down') !== -1) {
|
|
|
5165 //this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_unique(this._data[ t ? 'core' : 'checkbox' ].selected.concat(obj.children_d));
|
|
|
5166 var selectedIds = this._cascade_new_checked_state(obj.id, true);
|
|
|
5167 var temp = obj.children_d.concat(obj.id);
|
|
|
5168 for (i = 0, j = temp.length; i < j; i++) {
|
|
|
5169 if (selectedIds.indexOf(temp[i]) > -1) {
|
|
|
5170 sel[temp[i]] = true;
|
|
|
5171 }
|
|
|
5172 else {
|
|
|
5173 delete sel[temp[i]];
|
|
|
5174 }
|
|
|
5175 }
|
|
|
5176 }
|
|
|
5177
|
|
|
5178 // apply up
|
|
|
5179 if(s.indexOf('up') !== -1) {
|
|
|
5180 while(par && par.id !== $.jstree.root) {
|
|
|
5181 c = 0;
|
|
|
5182 for(i = 0, j = par.children.length; i < j; i++) {
|
|
|
5183 c += m[par.children[i]].state[ t ? 'selected' : 'checked' ];
|
|
|
5184 }
|
|
|
5185 if(c === j) {
|
|
|
5186 par.state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5187 sel[par.id] = true;
|
|
|
5188 //this._data[ t ? 'core' : 'checkbox' ].selected.push(par.id);
|
|
|
5189 tmp = this.get_node(par, true);
|
|
|
5190 if(tmp && tmp.length) {
|
|
|
5191 tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5192 }
|
|
|
5193 }
|
|
|
5194 else {
|
|
|
5195 break;
|
|
|
5196 }
|
|
|
5197 par = this.get_node(par.parent);
|
|
|
5198 }
|
|
|
5199 }
|
|
|
5200
|
|
|
5201 cur = [];
|
|
|
5202 for (i in sel) {
|
|
|
5203 if (sel.hasOwnProperty(i)) {
|
|
|
5204 cur.push(i);
|
|
|
5205 }
|
|
|
5206 }
|
|
|
5207 this._data[ t ? 'core' : 'checkbox' ].selected = cur;
|
|
|
5208 }, this))
|
|
|
5209 .on(this.settings.checkbox.tie_selection ? 'deselect_all.jstree' : 'uncheck_all.jstree', $.proxy(function (e, data) {
|
|
|
5210 var obj = this.get_node($.jstree.root),
|
|
|
5211 m = this._model.data,
|
|
|
5212 i, j, tmp;
|
|
|
5213 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
5214 tmp = m[obj.children_d[i]];
|
|
|
5215 if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {
|
|
|
5216 tmp.original.state.undetermined = false;
|
|
|
5217 }
|
|
|
5218 }
|
|
|
5219 }, this))
|
|
|
5220 .on(this.settings.checkbox.tie_selection ? 'deselect_node.jstree' : 'uncheck_node.jstree', $.proxy(function (e, data) {
|
|
|
5221 var self = this,
|
|
|
5222 obj = data.node,
|
|
|
5223 dom = this.get_node(obj, true),
|
|
|
5224 i, j, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection,
|
|
|
5225 cur = this._data[ t ? 'core' : 'checkbox' ].selected, sel = {},
|
|
|
5226 stillSelectedIds = [],
|
|
|
5227 allIds = obj.children_d.concat(obj.id);
|
|
|
5228
|
|
|
5229 // apply down
|
|
|
5230 if(s.indexOf('down') !== -1) {
|
|
|
5231 var selectedIds = this._cascade_new_checked_state(obj.id, false);
|
|
|
5232
|
|
|
5233 cur = cur.filter(function(id) {
|
|
|
5234 return allIds.indexOf(id) === -1 || selectedIds.indexOf(id) > -1;
|
|
|
5235 });
|
|
|
5236 }
|
|
|
5237
|
|
|
5238 // only apply up if cascade up is enabled and if this node is not selected
|
|
|
5239 // (if all child nodes are disabled and cascade_to_disabled === false then this node will till be selected).
|
|
|
5240 if(s.indexOf('up') !== -1 && cur.indexOf(obj.id) === -1) {
|
|
|
5241 for(i = 0, j = obj.parents.length; i < j; i++) {
|
|
|
5242 tmp = this._model.data[obj.parents[i]];
|
|
|
5243 tmp.state[ t ? 'selected' : 'checked' ] = false;
|
|
|
5244 if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {
|
|
|
5245 tmp.original.state.undetermined = false;
|
|
|
5246 }
|
|
|
5247 tmp = this.get_node(obj.parents[i], true);
|
|
|
5248 if(tmp && tmp.length) {
|
|
|
5249 tmp.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5250 }
|
|
|
5251 }
|
|
|
5252
|
|
|
5253 cur = cur.filter(function(id) {
|
|
|
5254 return obj.parents.indexOf(id) === -1;
|
|
|
5255 });
|
|
|
5256 }
|
|
|
5257
|
|
|
5258 this._data[ t ? 'core' : 'checkbox' ].selected = cur;
|
|
|
5259 }, this));
|
|
|
5260 }
|
|
|
5261 if(this.settings.checkbox.cascade.indexOf('up') !== -1) {
|
|
|
5262 this.element
|
|
|
5263 .on('delete_node.jstree', $.proxy(function (e, data) {
|
|
|
5264 // apply up (whole handler)
|
|
|
5265 var p = this.get_node(data.parent),
|
|
|
5266 m = this._model.data,
|
|
|
5267 i, j, c, tmp, t = this.settings.checkbox.tie_selection;
|
|
|
5268 while(p && p.id !== $.jstree.root && !p.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5269 c = 0;
|
|
|
5270 for(i = 0, j = p.children.length; i < j; i++) {
|
|
|
5271 c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];
|
|
|
5272 }
|
|
|
5273 if(j > 0 && c === j) {
|
|
|
5274 p.state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5275 this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);
|
|
|
5276 tmp = this.get_node(p, true);
|
|
|
5277 if(tmp && tmp.length) {
|
|
|
5278 tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5279 }
|
|
|
5280 }
|
|
|
5281 else {
|
|
|
5282 break;
|
|
|
5283 }
|
|
|
5284 p = this.get_node(p.parent);
|
|
|
5285 }
|
|
|
5286 }, this))
|
|
|
5287 .on('move_node.jstree', $.proxy(function (e, data) {
|
|
|
5288 // apply up (whole handler)
|
|
|
5289 var is_multi = data.is_multi,
|
|
|
5290 old_par = data.old_parent,
|
|
|
5291 new_par = this.get_node(data.parent),
|
|
|
5292 m = this._model.data,
|
|
|
5293 p, c, i, j, tmp, t = this.settings.checkbox.tie_selection;
|
|
|
5294 if(!is_multi) {
|
|
|
5295 p = this.get_node(old_par);
|
|
|
5296 while(p && p.id !== $.jstree.root && !p.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5297 c = 0;
|
|
|
5298 for(i = 0, j = p.children.length; i < j; i++) {
|
|
|
5299 c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];
|
|
|
5300 }
|
|
|
5301 if(j > 0 && c === j) {
|
|
|
5302 p.state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5303 this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);
|
|
|
5304 tmp = this.get_node(p, true);
|
|
|
5305 if(tmp && tmp.length) {
|
|
|
5306 tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5307 }
|
|
|
5308 }
|
|
|
5309 else {
|
|
|
5310 break;
|
|
|
5311 }
|
|
|
5312 p = this.get_node(p.parent);
|
|
|
5313 }
|
|
|
5314 }
|
|
|
5315 p = new_par;
|
|
|
5316 while(p && p.id !== $.jstree.root) {
|
|
|
5317 c = 0;
|
|
|
5318 for(i = 0, j = p.children.length; i < j; i++) {
|
|
|
5319 c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];
|
|
|
5320 }
|
|
|
5321 if(c === j) {
|
|
|
5322 if(!p.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5323 p.state[ t ? 'selected' : 'checked' ] = true;
|
|
|
5324 this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);
|
|
|
5325 tmp = this.get_node(p, true);
|
|
|
5326 if(tmp && tmp.length) {
|
|
|
5327 tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5328 }
|
|
|
5329 }
|
|
|
5330 }
|
|
|
5331 else {
|
|
|
5332 if(p.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5333 p.state[ t ? 'selected' : 'checked' ] = false;
|
|
|
5334 this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_remove_item(this._data[ t ? 'core' : 'checkbox' ].selected, p.id);
|
|
|
5335 tmp = this.get_node(p, true);
|
|
|
5336 if(tmp && tmp.length) {
|
|
|
5337 tmp.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5338 }
|
|
|
5339 }
|
|
|
5340 else {
|
|
|
5341 break;
|
|
|
5342 }
|
|
|
5343 }
|
|
|
5344 p = this.get_node(p.parent);
|
|
|
5345 }
|
|
|
5346 }, this));
|
|
|
5347 }
|
|
|
5348 };
|
|
|
5349 /**
|
|
|
5350 * get an array of all nodes whose state is "undetermined"
|
|
|
5351 * @name get_undetermined([full])
|
|
|
5352 * @param {boolean} full: if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
5353 * @return {Array}
|
|
|
5354 * @plugin checkbox
|
|
|
5355 */
|
|
|
5356 this.get_undetermined = function (full) {
|
|
|
5357 if (this.settings.checkbox.cascade.indexOf('undetermined') === -1) {
|
|
|
5358 return [];
|
|
|
5359 }
|
|
|
5360 var i, j, k, l, o = {}, m = this._model.data, t = this.settings.checkbox.tie_selection, s = this._data[ t ? 'core' : 'checkbox' ].selected, p = [], tt = this, r = [];
|
|
|
5361 for(i = 0, j = s.length; i < j; i++) {
|
|
|
5362 if(m[s[i]] && m[s[i]].parents) {
|
|
|
5363 for(k = 0, l = m[s[i]].parents.length; k < l; k++) {
|
|
|
5364 if(o[m[s[i]].parents[k]] !== undefined) {
|
|
|
5365 break;
|
|
|
5366 }
|
|
|
5367 if(m[s[i]].parents[k] !== $.jstree.root) {
|
|
|
5368 o[m[s[i]].parents[k]] = true;
|
|
|
5369 p.push(m[s[i]].parents[k]);
|
|
|
5370 }
|
|
|
5371 }
|
|
|
5372 }
|
|
|
5373 }
|
|
|
5374 // attempt for server side undetermined state
|
|
|
5375 this.element.find('.jstree-closed').not(':has(.jstree-children)')
|
|
|
5376 .each(function () {
|
|
|
5377 var tmp = tt.get_node(this), tmp2;
|
|
|
5378
|
|
|
5379 if(!tmp) { return; }
|
|
|
5380
|
|
|
5381 if(!tmp.state.loaded) {
|
|
|
5382 if(tmp.original && tmp.original.state && tmp.original.state.undetermined && tmp.original.state.undetermined === true) {
|
|
|
5383 if(o[tmp.id] === undefined && tmp.id !== $.jstree.root) {
|
|
|
5384 o[tmp.id] = true;
|
|
|
5385 p.push(tmp.id);
|
|
|
5386 }
|
|
|
5387 for(k = 0, l = tmp.parents.length; k < l; k++) {
|
|
|
5388 if(o[tmp.parents[k]] === undefined && tmp.parents[k] !== $.jstree.root) {
|
|
|
5389 o[tmp.parents[k]] = true;
|
|
|
5390 p.push(tmp.parents[k]);
|
|
|
5391 }
|
|
|
5392 }
|
|
|
5393 }
|
|
|
5394 }
|
|
|
5395 else {
|
|
|
5396 for(i = 0, j = tmp.children_d.length; i < j; i++) {
|
|
|
5397 tmp2 = m[tmp.children_d[i]];
|
|
|
5398 if(!tmp2.state.loaded && tmp2.original && tmp2.original.state && tmp2.original.state.undetermined && tmp2.original.state.undetermined === true) {
|
|
|
5399 if(o[tmp2.id] === undefined && tmp2.id !== $.jstree.root) {
|
|
|
5400 o[tmp2.id] = true;
|
|
|
5401 p.push(tmp2.id);
|
|
|
5402 }
|
|
|
5403 for(k = 0, l = tmp2.parents.length; k < l; k++) {
|
|
|
5404 if(o[tmp2.parents[k]] === undefined && tmp2.parents[k] !== $.jstree.root) {
|
|
|
5405 o[tmp2.parents[k]] = true;
|
|
|
5406 p.push(tmp2.parents[k]);
|
|
|
5407 }
|
|
|
5408 }
|
|
|
5409 }
|
|
|
5410 }
|
|
|
5411 }
|
|
|
5412 });
|
|
|
5413 for (i = 0, j = p.length; i < j; i++) {
|
|
|
5414 if(!m[p[i]].state[ t ? 'selected' : 'checked' ]) {
|
|
|
5415 r.push(full ? m[p[i]] : p[i]);
|
|
|
5416 }
|
|
|
5417 }
|
|
|
5418 return r;
|
|
|
5419 };
|
|
|
5420 /**
|
|
|
5421 * set the undetermined state where and if necessary. Used internally.
|
|
|
5422 * @private
|
|
|
5423 * @name _undetermined()
|
|
|
5424 * @plugin checkbox
|
|
|
5425 */
|
|
|
5426 this._undetermined = function () {
|
|
|
5427 if(this.element === null) { return; }
|
|
|
5428 var p = this.get_undetermined(false), i, j, s;
|
|
|
5429
|
|
|
5430 this.element.find('.jstree-undetermined').removeClass('jstree-undetermined');
|
|
|
5431 for (i = 0, j = p.length; i < j; i++) {
|
|
|
5432 s = this.get_node(p[i], true);
|
|
|
5433 if(s && s.length) {
|
|
|
5434 s.children('.jstree-anchor').children('.jstree-checkbox').addClass('jstree-undetermined');
|
|
|
5435 }
|
|
|
5436 }
|
|
|
5437 };
|
|
|
5438 this.redraw_node = function(obj, deep, is_callback, force_render) {
|
|
|
5439 obj = parent.redraw_node.apply(this, arguments);
|
|
|
5440 if(obj) {
|
|
|
5441 var i, j, tmp = null, icon = null;
|
|
|
5442 for(i = 0, j = obj.childNodes.length; i < j; i++) {
|
|
|
5443 if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {
|
|
|
5444 tmp = obj.childNodes[i];
|
|
|
5445 break;
|
|
|
5446 }
|
|
|
5447 }
|
|
|
5448 if(tmp) {
|
|
|
5449 if(!this.settings.checkbox.tie_selection && this._model.data[obj.id].state.checked) { tmp.className += ' jstree-checked'; }
|
|
|
5450 icon = _i.cloneNode(false);
|
|
|
5451 if(this._model.data[obj.id].state.checkbox_disabled) { icon.className += ' jstree-checkbox-disabled'; }
|
|
|
5452 tmp.insertBefore(icon, tmp.childNodes[0]);
|
|
|
5453 }
|
|
|
5454 }
|
|
|
5455 if(!is_callback && this.settings.checkbox.cascade.indexOf('undetermined') !== -1) {
|
|
|
5456 if(this._data.checkbox.uto) { clearTimeout(this._data.checkbox.uto); }
|
|
|
5457 this._data.checkbox.uto = setTimeout($.proxy(this._undetermined, this), 50);
|
|
|
5458 }
|
|
|
5459 return obj;
|
|
|
5460 };
|
|
|
5461 /**
|
|
|
5462 * show the node checkbox icons
|
|
|
5463 * @name show_checkboxes()
|
|
|
5464 * @plugin checkbox
|
|
|
5465 */
|
|
|
5466 this.show_checkboxes = function () { this._data.core.themes.checkboxes = true; this.get_container_ul().removeClass("jstree-no-checkboxes"); };
|
|
|
5467 /**
|
|
|
5468 * hide the node checkbox icons
|
|
|
5469 * @name hide_checkboxes()
|
|
|
5470 * @plugin checkbox
|
|
|
5471 */
|
|
|
5472 this.hide_checkboxes = function () { this._data.core.themes.checkboxes = false; this.get_container_ul().addClass("jstree-no-checkboxes"); };
|
|
|
5473 /**
|
|
|
5474 * toggle the node icons
|
|
|
5475 * @name toggle_checkboxes()
|
|
|
5476 * @plugin checkbox
|
|
|
5477 */
|
|
|
5478 this.toggle_checkboxes = function () { if(this._data.core.themes.checkboxes) { this.hide_checkboxes(); } else { this.show_checkboxes(); } };
|
|
|
5479 /**
|
|
|
5480 * checks if a node is in an undetermined state
|
|
|
5481 * @name is_undetermined(obj)
|
|
|
5482 * @param {mixed} obj
|
|
|
5483 * @return {Boolean}
|
|
|
5484 */
|
|
|
5485 this.is_undetermined = function (obj) {
|
|
|
5486 obj = this.get_node(obj);
|
|
|
5487 var s = this.settings.checkbox.cascade, i, j, t = this.settings.checkbox.tie_selection, d = this._data[ t ? 'core' : 'checkbox' ].selected, m = this._model.data;
|
|
|
5488 if(!obj || obj.state[ t ? 'selected' : 'checked' ] === true || s.indexOf('undetermined') === -1 || (s.indexOf('down') === -1 && s.indexOf('up') === -1)) {
|
|
|
5489 return false;
|
|
|
5490 }
|
|
|
5491 if(!obj.state.loaded && obj.original.state.undetermined === true) {
|
|
|
5492 return true;
|
|
|
5493 }
|
|
|
5494 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
5495 if($.inArray(obj.children_d[i], d) !== -1 || (!m[obj.children_d[i]].state.loaded && m[obj.children_d[i]].original.state.undetermined)) {
|
|
|
5496 return true;
|
|
|
5497 }
|
|
|
5498 }
|
|
|
5499 return false;
|
|
|
5500 };
|
|
|
5501 /**
|
|
|
5502 * disable a node's checkbox
|
|
|
5503 * @name disable_checkbox(obj)
|
|
|
5504 * @param {mixed} obj an array can be used too
|
|
|
5505 * @trigger disable_checkbox.jstree
|
|
|
5506 * @plugin checkbox
|
|
|
5507 */
|
|
|
5508 this.disable_checkbox = function (obj) {
|
|
|
5509 var t1, t2, dom;
|
|
|
5510 if($.isArray(obj)) {
|
|
|
5511 obj = obj.slice();
|
|
|
5512 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
5513 this.disable_checkbox(obj[t1]);
|
|
|
5514 }
|
|
|
5515 return true;
|
|
|
5516 }
|
|
|
5517 obj = this.get_node(obj);
|
|
|
5518 if(!obj || obj.id === $.jstree.root) {
|
|
|
5519 return false;
|
|
|
5520 }
|
|
|
5521 dom = this.get_node(obj, true);
|
|
|
5522 if(!obj.state.checkbox_disabled) {
|
|
|
5523 obj.state.checkbox_disabled = true;
|
|
|
5524 if(dom && dom.length) {
|
|
|
5525 dom.children('.jstree-anchor').children('.jstree-checkbox').addClass('jstree-checkbox-disabled');
|
|
|
5526 }
|
|
|
5527 /**
|
|
|
5528 * triggered when an node's checkbox is disabled
|
|
|
5529 * @event
|
|
|
5530 * @name disable_checkbox.jstree
|
|
|
5531 * @param {Object} node
|
|
|
5532 * @plugin checkbox
|
|
|
5533 */
|
|
|
5534 this.trigger('disable_checkbox', { 'node' : obj });
|
|
|
5535 }
|
|
|
5536 };
|
|
|
5537 /**
|
|
|
5538 * enable a node's checkbox
|
|
|
5539 * @name disable_checkbox(obj)
|
|
|
5540 * @param {mixed} obj an array can be used too
|
|
|
5541 * @trigger enable_checkbox.jstree
|
|
|
5542 * @plugin checkbox
|
|
|
5543 */
|
|
|
5544 this.enable_checkbox = function (obj) {
|
|
|
5545 var t1, t2, dom;
|
|
|
5546 if($.isArray(obj)) {
|
|
|
5547 obj = obj.slice();
|
|
|
5548 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
5549 this.enable_checkbox(obj[t1]);
|
|
|
5550 }
|
|
|
5551 return true;
|
|
|
5552 }
|
|
|
5553 obj = this.get_node(obj);
|
|
|
5554 if(!obj || obj.id === $.jstree.root) {
|
|
|
5555 return false;
|
|
|
5556 }
|
|
|
5557 dom = this.get_node(obj, true);
|
|
|
5558 if(obj.state.checkbox_disabled) {
|
|
|
5559 obj.state.checkbox_disabled = false;
|
|
|
5560 if(dom && dom.length) {
|
|
|
5561 dom.children('.jstree-anchor').children('.jstree-checkbox').removeClass('jstree-checkbox-disabled');
|
|
|
5562 }
|
|
|
5563 /**
|
|
|
5564 * triggered when an node's checkbox is enabled
|
|
|
5565 * @event
|
|
|
5566 * @name enable_checkbox.jstree
|
|
|
5567 * @param {Object} node
|
|
|
5568 * @plugin checkbox
|
|
|
5569 */
|
|
|
5570 this.trigger('enable_checkbox', { 'node' : obj });
|
|
|
5571 }
|
|
|
5572 };
|
|
|
5573
|
|
|
5574 this.activate_node = function (obj, e) {
|
|
|
5575 if($(e.target).hasClass('jstree-checkbox-disabled')) {
|
|
|
5576 return false;
|
|
|
5577 }
|
|
|
5578 if(this.settings.checkbox.tie_selection && (this.settings.checkbox.whole_node || $(e.target).hasClass('jstree-checkbox'))) {
|
|
|
5579 e.ctrlKey = true;
|
|
|
5580 }
|
|
|
5581 if(this.settings.checkbox.tie_selection || (!this.settings.checkbox.whole_node && !$(e.target).hasClass('jstree-checkbox'))) {
|
|
|
5582 return parent.activate_node.call(this, obj, e);
|
|
|
5583 }
|
|
|
5584 if(this.is_disabled(obj)) {
|
|
|
5585 return false;
|
|
|
5586 }
|
|
|
5587 if(this.is_checked(obj)) {
|
|
|
5588 this.uncheck_node(obj, e);
|
|
|
5589 }
|
|
|
5590 else {
|
|
|
5591 this.check_node(obj, e);
|
|
|
5592 }
|
|
|
5593 this.trigger('activate_node', { 'node' : this.get_node(obj) });
|
|
|
5594 };
|
|
|
5595
|
|
|
5596 /**
|
|
|
5597 * Cascades checked state to a node and all its descendants. This function does NOT affect hidden and disabled nodes (or their descendants).
|
|
|
5598 * However if these unaffected nodes are already selected their ids will be included in the returned array.
|
|
|
5599 * @private
|
|
|
5600 * @param {string} id the node ID
|
|
|
5601 * @param {bool} checkedState should the nodes be checked or not
|
|
|
5602 * @returns {Array} Array of all node id's (in this tree branch) that are checked.
|
|
|
5603 */
|
|
|
5604 this._cascade_new_checked_state = function (id, checkedState) {
|
|
|
5605 var self = this;
|
|
|
5606 var t = this.settings.checkbox.tie_selection;
|
|
|
5607 var node = this._model.data[id];
|
|
|
5608 var selectedNodeIds = [];
|
|
|
5609 var selectedChildrenIds = [], i, j, selectedChildIds;
|
|
|
5610
|
|
|
5611 if (
|
|
|
5612 (this.settings.checkbox.cascade_to_disabled || !node.state.disabled) &&
|
|
|
5613 (this.settings.checkbox.cascade_to_hidden || !node.state.hidden)
|
|
|
5614 ) {
|
|
|
5615 //First try and check/uncheck the children
|
|
|
5616 if (node.children) {
|
|
|
5617 for (i = 0, j = node.children.length; i < j; i++) {
|
|
|
5618 var childId = node.children[i];
|
|
|
5619 selectedChildIds = self._cascade_new_checked_state(childId, checkedState);
|
|
|
5620 selectedNodeIds = selectedNodeIds.concat(selectedChildIds);
|
|
|
5621 if (selectedChildIds.indexOf(childId) > -1) {
|
|
|
5622 selectedChildrenIds.push(childId);
|
|
|
5623 }
|
|
|
5624 }
|
|
|
5625 }
|
|
|
5626
|
|
|
5627 var dom = self.get_node(node, true);
|
|
|
5628
|
|
|
5629 //A node's state is undetermined if some but not all of it's children are checked/selected .
|
|
|
5630 var undetermined = selectedChildrenIds.length > 0 && selectedChildrenIds.length < node.children.length;
|
|
|
5631
|
|
|
5632 if(node.original && node.original.state && node.original.state.undetermined) {
|
|
|
5633 node.original.state.undetermined = undetermined;
|
|
|
5634 }
|
|
|
5635
|
|
|
5636 //If a node is undetermined then remove selected class
|
|
|
5637 if (undetermined) {
|
|
|
5638 node.state[ t ? 'selected' : 'checked' ] = false;
|
|
|
5639 dom.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5640 }
|
|
|
5641 //Otherwise, if the checkedState === true (i.e. the node is being checked now) and all of the node's children are checked (if it has any children),
|
|
|
5642 //check the node and style it correctly.
|
|
|
5643 else if (checkedState && selectedChildrenIds.length === node.children.length) {
|
|
|
5644 node.state[ t ? 'selected' : 'checked' ] = checkedState;
|
|
|
5645 selectedNodeIds.push(node.id);
|
|
|
5646
|
|
|
5647 dom.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5648 }
|
|
|
5649 else {
|
|
|
5650 node.state[ t ? 'selected' : 'checked' ] = false;
|
|
|
5651 dom.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');
|
|
|
5652 }
|
|
|
5653 }
|
|
|
5654 else {
|
|
|
5655 selectedChildIds = this.get_checked_descendants(id);
|
|
|
5656
|
|
|
5657 if (node.state[ t ? 'selected' : 'checked' ]) {
|
|
|
5658 selectedChildIds.push(node.id);
|
|
|
5659 }
|
|
|
5660
|
|
|
5661 selectedNodeIds = selectedNodeIds.concat(selectedChildIds);
|
|
|
5662 }
|
|
|
5663
|
|
|
5664 return selectedNodeIds;
|
|
|
5665 };
|
|
|
5666
|
|
|
5667 /**
|
|
|
5668 * Gets ids of nodes selected in branch (of tree) specified by id (does not include the node specified by id)
|
|
|
5669 * @name get_checked_descendants(obj)
|
|
|
5670 * @param {string} id the node ID
|
|
|
5671 * @return {Array} array of IDs
|
|
|
5672 * @plugin checkbox
|
|
|
5673 */
|
|
|
5674 this.get_checked_descendants = function (id) {
|
|
|
5675 var self = this;
|
|
|
5676 var t = self.settings.checkbox.tie_selection;
|
|
|
5677 var node = self._model.data[id];
|
|
|
5678
|
|
|
5679 return node.children_d.filter(function(_id) {
|
|
|
5680 return self._model.data[_id].state[ t ? 'selected' : 'checked' ];
|
|
|
5681 });
|
|
|
5682 };
|
|
|
5683
|
|
|
5684 /**
|
|
|
5685 * check a node (only if tie_selection in checkbox settings is false, otherwise select_node will be called internally)
|
|
|
5686 * @name check_node(obj)
|
|
|
5687 * @param {mixed} obj an array can be used to check multiple nodes
|
|
|
5688 * @trigger check_node.jstree
|
|
|
5689 * @plugin checkbox
|
|
|
5690 */
|
|
|
5691 this.check_node = function (obj, e) {
|
|
|
5692 if(this.settings.checkbox.tie_selection) { return this.select_node(obj, false, true, e); }
|
|
|
5693 var dom, t1, t2, th;
|
|
|
5694 if($.isArray(obj)) {
|
|
|
5695 obj = obj.slice();
|
|
|
5696 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
5697 this.check_node(obj[t1], e);
|
|
|
5698 }
|
|
|
5699 return true;
|
|
|
5700 }
|
|
|
5701 obj = this.get_node(obj);
|
|
|
5702 if(!obj || obj.id === $.jstree.root) {
|
|
|
5703 return false;
|
|
|
5704 }
|
|
|
5705 dom = this.get_node(obj, true);
|
|
|
5706 if(!obj.state.checked) {
|
|
|
5707 obj.state.checked = true;
|
|
|
5708 this._data.checkbox.selected.push(obj.id);
|
|
|
5709 if(dom && dom.length) {
|
|
|
5710 dom.children('.jstree-anchor').addClass('jstree-checked');
|
|
|
5711 }
|
|
|
5712 /**
|
|
|
5713 * triggered when an node is checked (only if tie_selection in checkbox settings is false)
|
|
|
5714 * @event
|
|
|
5715 * @name check_node.jstree
|
|
|
5716 * @param {Object} node
|
|
|
5717 * @param {Array} selected the current selection
|
|
|
5718 * @param {Object} event the event (if any) that triggered this check_node
|
|
|
5719 * @plugin checkbox
|
|
|
5720 */
|
|
|
5721 this.trigger('check_node', { 'node' : obj, 'selected' : this._data.checkbox.selected, 'event' : e });
|
|
|
5722 }
|
|
|
5723 };
|
|
|
5724 /**
|
|
|
5725 * uncheck a node (only if tie_selection in checkbox settings is false, otherwise deselect_node will be called internally)
|
|
|
5726 * @name uncheck_node(obj)
|
|
|
5727 * @param {mixed} obj an array can be used to uncheck multiple nodes
|
|
|
5728 * @trigger uncheck_node.jstree
|
|
|
5729 * @plugin checkbox
|
|
|
5730 */
|
|
|
5731 this.uncheck_node = function (obj, e) {
|
|
|
5732 if(this.settings.checkbox.tie_selection) { return this.deselect_node(obj, false, e); }
|
|
|
5733 var t1, t2, dom;
|
|
|
5734 if($.isArray(obj)) {
|
|
|
5735 obj = obj.slice();
|
|
|
5736 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
5737 this.uncheck_node(obj[t1], e);
|
|
|
5738 }
|
|
|
5739 return true;
|
|
|
5740 }
|
|
|
5741 obj = this.get_node(obj);
|
|
|
5742 if(!obj || obj.id === $.jstree.root) {
|
|
|
5743 return false;
|
|
|
5744 }
|
|
|
5745 dom = this.get_node(obj, true);
|
|
|
5746 if(obj.state.checked) {
|
|
|
5747 obj.state.checked = false;
|
|
|
5748 this._data.checkbox.selected = $.vakata.array_remove_item(this._data.checkbox.selected, obj.id);
|
|
|
5749 if(dom.length) {
|
|
|
5750 dom.children('.jstree-anchor').removeClass('jstree-checked');
|
|
|
5751 }
|
|
|
5752 /**
|
|
|
5753 * triggered when an node is unchecked (only if tie_selection in checkbox settings is false)
|
|
|
5754 * @event
|
|
|
5755 * @name uncheck_node.jstree
|
|
|
5756 * @param {Object} node
|
|
|
5757 * @param {Array} selected the current selection
|
|
|
5758 * @param {Object} event the event (if any) that triggered this uncheck_node
|
|
|
5759 * @plugin checkbox
|
|
|
5760 */
|
|
|
5761 this.trigger('uncheck_node', { 'node' : obj, 'selected' : this._data.checkbox.selected, 'event' : e });
|
|
|
5762 }
|
|
|
5763 };
|
|
|
5764
|
|
|
5765 /**
|
|
|
5766 * checks all nodes in the tree (only if tie_selection in checkbox settings is false, otherwise select_all will be called internally)
|
|
|
5767 * @name check_all()
|
|
|
5768 * @trigger check_all.jstree, changed.jstree
|
|
|
5769 * @plugin checkbox
|
|
|
5770 */
|
|
|
5771 this.check_all = function () {
|
|
|
5772 if(this.settings.checkbox.tie_selection) { return this.select_all(); }
|
|
|
5773 var tmp = this._data.checkbox.selected.concat([]), i, j;
|
|
|
5774 this._data.checkbox.selected = this._model.data[$.jstree.root].children_d.concat();
|
|
|
5775 for(i = 0, j = this._data.checkbox.selected.length; i < j; i++) {
|
|
|
5776 if(this._model.data[this._data.checkbox.selected[i]]) {
|
|
|
5777 this._model.data[this._data.checkbox.selected[i]].state.checked = true;
|
|
|
5778 }
|
|
|
5779 }
|
|
|
5780 this.redraw(true);
|
|
|
5781 /**
|
|
|
5782 * triggered when all nodes are checked (only if tie_selection in checkbox settings is false)
|
|
|
5783 * @event
|
|
|
5784 * @name check_all.jstree
|
|
|
5785 * @param {Array} selected the current selection
|
|
|
5786 * @plugin checkbox
|
|
|
5787 */
|
|
|
5788 this.trigger('check_all', { 'selected' : this._data.checkbox.selected });
|
|
|
5789 };
|
|
|
5790 /**
|
|
|
5791 * uncheck all checked nodes (only if tie_selection in checkbox settings is false, otherwise deselect_all will be called internally)
|
|
|
5792 * @name uncheck_all()
|
|
|
5793 * @trigger uncheck_all.jstree
|
|
|
5794 * @plugin checkbox
|
|
|
5795 */
|
|
|
5796 this.uncheck_all = function () {
|
|
|
5797 if(this.settings.checkbox.tie_selection) { return this.deselect_all(); }
|
|
|
5798 var tmp = this._data.checkbox.selected.concat([]), i, j;
|
|
|
5799 for(i = 0, j = this._data.checkbox.selected.length; i < j; i++) {
|
|
|
5800 if(this._model.data[this._data.checkbox.selected[i]]) {
|
|
|
5801 this._model.data[this._data.checkbox.selected[i]].state.checked = false;
|
|
|
5802 }
|
|
|
5803 }
|
|
|
5804 this._data.checkbox.selected = [];
|
|
|
5805 this.element.find('.jstree-checked').removeClass('jstree-checked');
|
|
|
5806 /**
|
|
|
5807 * triggered when all nodes are unchecked (only if tie_selection in checkbox settings is false)
|
|
|
5808 * @event
|
|
|
5809 * @name uncheck_all.jstree
|
|
|
5810 * @param {Object} node the previous selection
|
|
|
5811 * @param {Array} selected the current selection
|
|
|
5812 * @plugin checkbox
|
|
|
5813 */
|
|
|
5814 this.trigger('uncheck_all', { 'selected' : this._data.checkbox.selected, 'node' : tmp });
|
|
|
5815 };
|
|
|
5816 /**
|
|
|
5817 * checks if a node is checked (if tie_selection is on in the settings this function will return the same as is_selected)
|
|
|
5818 * @name is_checked(obj)
|
|
|
5819 * @param {mixed} obj
|
|
|
5820 * @return {Boolean}
|
|
|
5821 * @plugin checkbox
|
|
|
5822 */
|
|
|
5823 this.is_checked = function (obj) {
|
|
|
5824 if(this.settings.checkbox.tie_selection) { return this.is_selected(obj); }
|
|
|
5825 obj = this.get_node(obj);
|
|
|
5826 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
5827 return obj.state.checked;
|
|
|
5828 };
|
|
|
5829 /**
|
|
|
5830 * get an array of all checked nodes (if tie_selection is on in the settings this function will return the same as get_selected)
|
|
|
5831 * @name get_checked([full])
|
|
|
5832 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
5833 * @return {Array}
|
|
|
5834 * @plugin checkbox
|
|
|
5835 */
|
|
|
5836 this.get_checked = function (full) {
|
|
|
5837 if(this.settings.checkbox.tie_selection) { return this.get_selected(full); }
|
|
|
5838 return full ? $.map(this._data.checkbox.selected, $.proxy(function (i) { return this.get_node(i); }, this)) : this._data.checkbox.selected;
|
|
|
5839 };
|
|
|
5840 /**
|
|
|
5841 * get an array of all top level checked nodes (ignoring children of checked nodes) (if tie_selection is on in the settings this function will return the same as get_top_selected)
|
|
|
5842 * @name get_top_checked([full])
|
|
|
5843 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
5844 * @return {Array}
|
|
|
5845 * @plugin checkbox
|
|
|
5846 */
|
|
|
5847 this.get_top_checked = function (full) {
|
|
|
5848 if(this.settings.checkbox.tie_selection) { return this.get_top_selected(full); }
|
|
|
5849 var tmp = this.get_checked(true),
|
|
|
5850 obj = {}, i, j, k, l;
|
|
|
5851 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
5852 obj[tmp[i].id] = tmp[i];
|
|
|
5853 }
|
|
|
5854 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
5855 for(k = 0, l = tmp[i].children_d.length; k < l; k++) {
|
|
|
5856 if(obj[tmp[i].children_d[k]]) {
|
|
|
5857 delete obj[tmp[i].children_d[k]];
|
|
|
5858 }
|
|
|
5859 }
|
|
|
5860 }
|
|
|
5861 tmp = [];
|
|
|
5862 for(i in obj) {
|
|
|
5863 if(obj.hasOwnProperty(i)) {
|
|
|
5864 tmp.push(i);
|
|
|
5865 }
|
|
|
5866 }
|
|
|
5867 return full ? $.map(tmp, $.proxy(function (i) { return this.get_node(i); }, this)) : tmp;
|
|
|
5868 };
|
|
|
5869 /**
|
|
|
5870 * get an array of all bottom level checked nodes (ignoring selected parents) (if tie_selection is on in the settings this function will return the same as get_bottom_selected)
|
|
|
5871 * @name get_bottom_checked([full])
|
|
|
5872 * @param {mixed} full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned
|
|
|
5873 * @return {Array}
|
|
|
5874 * @plugin checkbox
|
|
|
5875 */
|
|
|
5876 this.get_bottom_checked = function (full) {
|
|
|
5877 if(this.settings.checkbox.tie_selection) { return this.get_bottom_selected(full); }
|
|
|
5878 var tmp = this.get_checked(true),
|
|
|
5879 obj = [], i, j;
|
|
|
5880 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
5881 if(!tmp[i].children.length) {
|
|
|
5882 obj.push(tmp[i].id);
|
|
|
5883 }
|
|
|
5884 }
|
|
|
5885 return full ? $.map(obj, $.proxy(function (i) { return this.get_node(i); }, this)) : obj;
|
|
|
5886 };
|
|
|
5887 this.load_node = function (obj, callback) {
|
|
|
5888 var k, l, i, j, c, tmp;
|
|
|
5889 if(!$.isArray(obj) && !this.settings.checkbox.tie_selection) {
|
|
|
5890 tmp = this.get_node(obj);
|
|
|
5891 if(tmp && tmp.state.loaded) {
|
|
|
5892 for(k = 0, l = tmp.children_d.length; k < l; k++) {
|
|
|
5893 if(this._model.data[tmp.children_d[k]].state.checked) {
|
|
|
5894 c = true;
|
|
|
5895 this._data.checkbox.selected = $.vakata.array_remove_item(this._data.checkbox.selected, tmp.children_d[k]);
|
|
|
5896 }
|
|
|
5897 }
|
|
|
5898 }
|
|
|
5899 }
|
|
|
5900 return parent.load_node.apply(this, arguments);
|
|
|
5901 };
|
|
|
5902 this.get_state = function () {
|
|
|
5903 var state = parent.get_state.apply(this, arguments);
|
|
|
5904 if(this.settings.checkbox.tie_selection) { return state; }
|
|
|
5905 state.checkbox = this._data.checkbox.selected.slice();
|
|
|
5906 return state;
|
|
|
5907 };
|
|
|
5908 this.set_state = function (state, callback) {
|
|
|
5909 var res = parent.set_state.apply(this, arguments);
|
|
|
5910 if(res && state.checkbox) {
|
|
|
5911 if(!this.settings.checkbox.tie_selection) {
|
|
|
5912 this.uncheck_all();
|
|
|
5913 var _this = this;
|
|
|
5914 $.each(state.checkbox, function (i, v) {
|
|
|
5915 _this.check_node(v);
|
|
|
5916 });
|
|
|
5917 }
|
|
|
5918 delete state.checkbox;
|
|
|
5919 this.set_state(state, callback);
|
|
|
5920 return false;
|
|
|
5921 }
|
|
|
5922 return res;
|
|
|
5923 };
|
|
|
5924 this.refresh = function (skip_loading, forget_state) {
|
|
|
5925 if(!this.settings.checkbox.tie_selection) {
|
|
|
5926 this._data.checkbox.selected = [];
|
|
|
5927 }
|
|
|
5928 return parent.refresh.apply(this, arguments);
|
|
|
5929 };
|
|
|
5930 };
|
|
|
5931
|
|
|
5932 // include the checkbox plugin by default
|
|
|
5933 // $.jstree.defaults.plugins.push("checkbox");
|
|
|
5934
|
|
|
5935
|
|
|
5936 /**
|
|
|
5937 * ### Conditionalselect plugin
|
|
|
5938 *
|
|
|
5939 * This plugin allows defining a callback to allow or deny node selection by user input (activate node method).
|
|
|
5940 */
|
|
|
5941
|
|
|
5942 /**
|
|
|
5943 * a callback (function) which is invoked in the instance's scope and receives two arguments - the node and the event that triggered the `activate_node` call. Returning false prevents working with the node, returning true allows invoking activate_node. Defaults to returning `true`.
|
|
|
5944 * @name $.jstree.defaults.checkbox.visible
|
|
|
5945 * @plugin checkbox
|
|
|
5946 */
|
|
|
5947 $.jstree.defaults.conditionalselect = function () { return true; };
|
|
|
5948 $.jstree.plugins.conditionalselect = function (options, parent) {
|
|
|
5949 // own function
|
|
|
5950 this.activate_node = function (obj, e) {
|
|
|
5951 if(this.settings.conditionalselect.call(this, this.get_node(obj), e)) {
|
|
|
5952 return parent.activate_node.call(this, obj, e);
|
|
|
5953 }
|
|
|
5954 };
|
|
|
5955 };
|
|
|
5956
|
|
|
5957
|
|
|
5958 /**
|
|
|
5959 * ### Contextmenu plugin
|
|
|
5960 *
|
|
|
5961 * Shows a context menu when a node is right-clicked.
|
|
|
5962 */
|
|
|
5963
|
|
|
5964 /**
|
|
|
5965 * stores all defaults for the contextmenu plugin
|
|
|
5966 * @name $.jstree.defaults.contextmenu
|
|
|
5967 * @plugin contextmenu
|
|
|
5968 */
|
|
|
5969 $.jstree.defaults.contextmenu = {
|
|
|
5970 /**
|
|
|
5971 * a boolean indicating if the node should be selected when the context menu is invoked on it. Defaults to `true`.
|
|
|
5972 * @name $.jstree.defaults.contextmenu.select_node
|
|
|
5973 * @plugin contextmenu
|
|
|
5974 */
|
|
|
5975 select_node : true,
|
|
|
5976 /**
|
|
|
5977 * a boolean indicating if the menu should be shown aligned with the node. Defaults to `true`, otherwise the mouse coordinates are used.
|
|
|
5978 * @name $.jstree.defaults.contextmenu.show_at_node
|
|
|
5979 * @plugin contextmenu
|
|
|
5980 */
|
|
|
5981 show_at_node : true,
|
|
|
5982 /**
|
|
|
5983 * an object of actions, or a function that accepts a node and a callback function and calls the callback function with an object of actions available for that node (you can also return the items too).
|
|
|
5984 *
|
|
|
5985 * Each action consists of a key (a unique name) and a value which is an object with the following properties (only label and action are required). Once a menu item is activated the `action` function will be invoked with an object containing the following keys: item - the contextmenu item definition as seen below, reference - the DOM node that was used (the tree node), element - the contextmenu DOM element, position - an object with x/y properties indicating the position of the menu.
|
|
|
5986 *
|
|
|
5987 * * `separator_before` - a boolean indicating if there should be a separator before this item
|
|
|
5988 * * `separator_after` - a boolean indicating if there should be a separator after this item
|
|
|
5989 * * `_disabled` - a boolean indicating if this action should be disabled
|
|
|
5990 * * `label` - a string - the name of the action (could be a function returning a string)
|
|
|
5991 * * `title` - a string - an optional tooltip for the item
|
|
|
5992 * * `action` - a function to be executed if this item is chosen, the function will receive
|
|
|
5993 * * `icon` - a string, can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class
|
|
|
5994 * * `shortcut` - keyCode which will trigger the action if the menu is open (for example `113` for rename, which equals F2)
|
|
|
5995 * * `shortcut_label` - shortcut label (like for example `F2` for rename)
|
|
|
5996 * * `submenu` - an object with the same structure as $.jstree.defaults.contextmenu.items which can be used to create a submenu - each key will be rendered as a separate option in a submenu that will appear once the current item is hovered
|
|
|
5997 *
|
|
|
5998 * @name $.jstree.defaults.contextmenu.items
|
|
|
5999 * @plugin contextmenu
|
|
|
6000 */
|
|
|
6001 items : function (o, cb) { // Could be an object directly
|
|
|
6002 return {
|
|
|
6003 "create" : {
|
|
|
6004 "separator_before" : false,
|
|
|
6005 "separator_after" : true,
|
|
|
6006 "_disabled" : false, //(this.check("create_node", data.reference, {}, "last")),
|
|
|
6007 "label" : "Create",
|
|
|
6008 "action" : function (data) {
|
|
|
6009 var inst = $.jstree.reference(data.reference),
|
|
|
6010 obj = inst.get_node(data.reference);
|
|
|
6011 inst.create_node(obj, {}, "last", function (new_node) {
|
|
|
6012 try {
|
|
|
6013 inst.edit(new_node);
|
|
|
6014 } catch (ex) {
|
|
|
6015 setTimeout(function () { inst.edit(new_node); },0);
|
|
|
6016 }
|
|
|
6017 });
|
|
|
6018 }
|
|
|
6019 },
|
|
|
6020 "rename" : {
|
|
|
6021 "separator_before" : false,
|
|
|
6022 "separator_after" : false,
|
|
|
6023 "_disabled" : false, //(this.check("rename_node", data.reference, this.get_parent(data.reference), "")),
|
|
|
6024 "label" : "Rename",
|
|
|
6025 /*!
|
|
|
6026 "shortcut" : 113,
|
|
|
6027 "shortcut_label" : 'F2',
|
|
|
6028 "icon" : "glyphicon glyphicon-leaf",
|
|
|
6029 */
|
|
|
6030 "action" : function (data) {
|
|
|
6031 var inst = $.jstree.reference(data.reference),
|
|
|
6032 obj = inst.get_node(data.reference);
|
|
|
6033 inst.edit(obj);
|
|
|
6034 }
|
|
|
6035 },
|
|
|
6036 "remove" : {
|
|
|
6037 "separator_before" : false,
|
|
|
6038 "icon" : false,
|
|
|
6039 "separator_after" : false,
|
|
|
6040 "_disabled" : false, //(this.check("delete_node", data.reference, this.get_parent(data.reference), "")),
|
|
|
6041 "label" : "Delete",
|
|
|
6042 "action" : function (data) {
|
|
|
6043 var inst = $.jstree.reference(data.reference),
|
|
|
6044 obj = inst.get_node(data.reference);
|
|
|
6045 if(inst.is_selected(obj)) {
|
|
|
6046 inst.delete_node(inst.get_selected());
|
|
|
6047 }
|
|
|
6048 else {
|
|
|
6049 inst.delete_node(obj);
|
|
|
6050 }
|
|
|
6051 }
|
|
|
6052 },
|
|
|
6053 "ccp" : {
|
|
|
6054 "separator_before" : true,
|
|
|
6055 "icon" : false,
|
|
|
6056 "separator_after" : false,
|
|
|
6057 "label" : "Edit",
|
|
|
6058 "action" : false,
|
|
|
6059 "submenu" : {
|
|
|
6060 "cut" : {
|
|
|
6061 "separator_before" : false,
|
|
|
6062 "separator_after" : false,
|
|
|
6063 "label" : "Cut",
|
|
|
6064 "action" : function (data) {
|
|
|
6065 var inst = $.jstree.reference(data.reference),
|
|
|
6066 obj = inst.get_node(data.reference);
|
|
|
6067 if(inst.is_selected(obj)) {
|
|
|
6068 inst.cut(inst.get_top_selected());
|
|
|
6069 }
|
|
|
6070 else {
|
|
|
6071 inst.cut(obj);
|
|
|
6072 }
|
|
|
6073 }
|
|
|
6074 },
|
|
|
6075 "copy" : {
|
|
|
6076 "separator_before" : false,
|
|
|
6077 "icon" : false,
|
|
|
6078 "separator_after" : false,
|
|
|
6079 "label" : "Copy",
|
|
|
6080 "action" : function (data) {
|
|
|
6081 var inst = $.jstree.reference(data.reference),
|
|
|
6082 obj = inst.get_node(data.reference);
|
|
|
6083 if(inst.is_selected(obj)) {
|
|
|
6084 inst.copy(inst.get_top_selected());
|
|
|
6085 }
|
|
|
6086 else {
|
|
|
6087 inst.copy(obj);
|
|
|
6088 }
|
|
|
6089 }
|
|
|
6090 },
|
|
|
6091 "paste" : {
|
|
|
6092 "separator_before" : false,
|
|
|
6093 "icon" : false,
|
|
|
6094 "_disabled" : function (data) {
|
|
|
6095 return !$.jstree.reference(data.reference).can_paste();
|
|
|
6096 },
|
|
|
6097 "separator_after" : false,
|
|
|
6098 "label" : "Paste",
|
|
|
6099 "action" : function (data) {
|
|
|
6100 var inst = $.jstree.reference(data.reference),
|
|
|
6101 obj = inst.get_node(data.reference);
|
|
|
6102 inst.paste(obj);
|
|
|
6103 }
|
|
|
6104 }
|
|
|
6105 }
|
|
|
6106 }
|
|
|
6107 };
|
|
|
6108 }
|
|
|
6109 };
|
|
|
6110
|
|
|
6111 $.jstree.plugins.contextmenu = function (options, parent) {
|
|
|
6112 this.bind = function () {
|
|
|
6113 parent.bind.call(this);
|
|
|
6114
|
|
|
6115 var last_ts = 0, cto = null, ex, ey;
|
|
|
6116 this.element
|
|
|
6117 .on("init.jstree loading.jstree ready.jstree", $.proxy(function () {
|
|
|
6118 this.get_container_ul().addClass('jstree-contextmenu');
|
|
|
6119 }, this))
|
|
|
6120 .on("contextmenu.jstree", ".jstree-anchor", $.proxy(function (e, data) {
|
|
|
6121 if (e.target.tagName.toLowerCase() === 'input') {
|
|
|
6122 return;
|
|
|
6123 }
|
|
|
6124 e.preventDefault();
|
|
|
6125 last_ts = e.ctrlKey ? +new Date() : 0;
|
|
|
6126 if(data || cto) {
|
|
|
6127 last_ts = (+new Date()) + 10000;
|
|
|
6128 }
|
|
|
6129 if(cto) {
|
|
|
6130 clearTimeout(cto);
|
|
|
6131 }
|
|
|
6132 if(!this.is_loading(e.currentTarget)) {
|
|
|
6133 this.show_contextmenu(e.currentTarget, e.pageX, e.pageY, e);
|
|
|
6134 }
|
|
|
6135 }, this))
|
|
|
6136 .on("click.jstree", ".jstree-anchor", $.proxy(function (e) {
|
|
|
6137 if(this._data.contextmenu.visible && (!last_ts || (+new Date()) - last_ts > 250)) { // work around safari & macOS ctrl+click
|
|
|
6138 $.vakata.context.hide();
|
|
|
6139 }
|
|
|
6140 last_ts = 0;
|
|
|
6141 }, this))
|
|
|
6142 .on("touchstart.jstree", ".jstree-anchor", function (e) {
|
|
|
6143 if(!e.originalEvent || !e.originalEvent.changedTouches || !e.originalEvent.changedTouches[0]) {
|
|
|
6144 return;
|
|
|
6145 }
|
|
|
6146 ex = e.originalEvent.changedTouches[0].clientX;
|
|
|
6147 ey = e.originalEvent.changedTouches[0].clientY;
|
|
|
6148 cto = setTimeout(function () {
|
|
|
6149 $(e.currentTarget).trigger('contextmenu', true);
|
|
|
6150 }, 750);
|
|
|
6151 })
|
|
|
6152 .on('touchmove.vakata.jstree', function (e) {
|
|
|
6153 if(cto && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0] && (Math.abs(ex - e.originalEvent.changedTouches[0].clientX) > 10 || Math.abs(ey - e.originalEvent.changedTouches[0].clientY) > 10)) {
|
|
|
6154 clearTimeout(cto);
|
|
|
6155 $.vakata.context.hide();
|
|
|
6156 }
|
|
|
6157 })
|
|
|
6158 .on('touchend.vakata.jstree', function (e) {
|
|
|
6159 if(cto) {
|
|
|
6160 clearTimeout(cto);
|
|
|
6161 }
|
|
|
6162 });
|
|
|
6163
|
|
|
6164 /*!
|
|
|
6165 if(!('oncontextmenu' in document.body) && ('ontouchstart' in document.body)) {
|
|
|
6166 var el = null, tm = null;
|
|
|
6167 this.element
|
|
|
6168 .on("touchstart", ".jstree-anchor", function (e) {
|
|
|
6169 el = e.currentTarget;
|
|
|
6170 tm = +new Date();
|
|
|
6171 $(document).one("touchend", function (e) {
|
|
|
6172 e.target = document.elementFromPoint(e.originalEvent.targetTouches[0].pageX - window.pageXOffset, e.originalEvent.targetTouches[0].pageY - window.pageYOffset);
|
|
|
6173 e.currentTarget = e.target;
|
|
|
6174 tm = ((+(new Date())) - tm);
|
|
|
6175 if(e.target === el && tm > 600 && tm < 1000) {
|
|
|
6176 e.preventDefault();
|
|
|
6177 $(el).trigger('contextmenu', e);
|
|
|
6178 }
|
|
|
6179 el = null;
|
|
|
6180 tm = null;
|
|
|
6181 });
|
|
|
6182 });
|
|
|
6183 }
|
|
|
6184 */
|
|
|
6185 $(document).on("context_hide.vakata.jstree", $.proxy(function (e, data) {
|
|
|
6186 this._data.contextmenu.visible = false;
|
|
|
6187 $(data.reference).removeClass('jstree-context');
|
|
|
6188 }, this));
|
|
|
6189 };
|
|
|
6190 this.teardown = function () {
|
|
|
6191 if(this._data.contextmenu.visible) {
|
|
|
6192 $.vakata.context.hide();
|
|
|
6193 }
|
|
|
6194 parent.teardown.call(this);
|
|
|
6195 };
|
|
|
6196
|
|
|
6197 /**
|
|
|
6198 * prepare and show the context menu for a node
|
|
|
6199 * @name show_contextmenu(obj [, x, y])
|
|
|
6200 * @param {mixed} obj the node
|
|
|
6201 * @param {Number} x the x-coordinate relative to the document to show the menu at
|
|
|
6202 * @param {Number} y the y-coordinate relative to the document to show the menu at
|
|
|
6203 * @param {Object} e the event if available that triggered the contextmenu
|
|
|
6204 * @plugin contextmenu
|
|
|
6205 * @trigger show_contextmenu.jstree
|
|
|
6206 */
|
|
|
6207 this.show_contextmenu = function (obj, x, y, e) {
|
|
|
6208 obj = this.get_node(obj);
|
|
|
6209 if(!obj || obj.id === $.jstree.root) { return false; }
|
|
|
6210 var s = this.settings.contextmenu,
|
|
|
6211 d = this.get_node(obj, true),
|
|
|
6212 a = d.children(".jstree-anchor"),
|
|
|
6213 o = false,
|
|
|
6214 i = false;
|
|
|
6215 if(s.show_at_node || x === undefined || y === undefined) {
|
|
|
6216 o = a.offset();
|
|
|
6217 x = o.left;
|
|
|
6218 y = o.top + this._data.core.li_height;
|
|
|
6219 }
|
|
|
6220 if(this.settings.contextmenu.select_node && !this.is_selected(obj)) {
|
|
|
6221 this.activate_node(obj, e);
|
|
|
6222 }
|
|
|
6223
|
|
|
6224 i = s.items;
|
|
|
6225 if($.isFunction(i)) {
|
|
|
6226 i = i.call(this, obj, $.proxy(function (i) {
|
|
|
6227 this._show_contextmenu(obj, x, y, i);
|
|
|
6228 }, this));
|
|
|
6229 }
|
|
|
6230 if($.isPlainObject(i)) {
|
|
|
6231 this._show_contextmenu(obj, x, y, i);
|
|
|
6232 }
|
|
|
6233 };
|
|
|
6234 /**
|
|
|
6235 * show the prepared context menu for a node
|
|
|
6236 * @name _show_contextmenu(obj, x, y, i)
|
|
|
6237 * @param {mixed} obj the node
|
|
|
6238 * @param {Number} x the x-coordinate relative to the document to show the menu at
|
|
|
6239 * @param {Number} y the y-coordinate relative to the document to show the menu at
|
|
|
6240 * @param {Number} i the object of items to show
|
|
|
6241 * @plugin contextmenu
|
|
|
6242 * @trigger show_contextmenu.jstree
|
|
|
6243 * @private
|
|
|
6244 */
|
|
|
6245 this._show_contextmenu = function (obj, x, y, i) {
|
|
|
6246 var d = this.get_node(obj, true),
|
|
|
6247 a = d.children(".jstree-anchor");
|
|
|
6248 $(document).one("context_show.vakata.jstree", $.proxy(function (e, data) {
|
|
|
6249 var cls = 'jstree-contextmenu jstree-' + this.get_theme() + '-contextmenu';
|
|
|
6250 $(data.element).addClass(cls);
|
|
|
6251 a.addClass('jstree-context');
|
|
|
6252 }, this));
|
|
|
6253 this._data.contextmenu.visible = true;
|
|
|
6254 $.vakata.context.show(a, { 'x' : x, 'y' : y }, i);
|
|
|
6255 /**
|
|
|
6256 * triggered when the contextmenu is shown for a node
|
|
|
6257 * @event
|
|
|
6258 * @name show_contextmenu.jstree
|
|
|
6259 * @param {Object} node the node
|
|
|
6260 * @param {Number} x the x-coordinate of the menu relative to the document
|
|
|
6261 * @param {Number} y the y-coordinate of the menu relative to the document
|
|
|
6262 * @plugin contextmenu
|
|
|
6263 */
|
|
|
6264 this.trigger('show_contextmenu', { "node" : obj, "x" : x, "y" : y });
|
|
|
6265 };
|
|
|
6266 };
|
|
|
6267
|
|
|
6268 // contextmenu helper
|
|
|
6269 (function ($) {
|
|
|
6270 var right_to_left = false,
|
|
|
6271 vakata_context = {
|
|
|
6272 element : false,
|
|
|
6273 reference : false,
|
|
|
6274 position_x : 0,
|
|
|
6275 position_y : 0,
|
|
|
6276 items : [],
|
|
|
6277 html : "",
|
|
|
6278 is_visible : false
|
|
|
6279 };
|
|
|
6280
|
|
|
6281 $.vakata.context = {
|
|
|
6282 settings : {
|
|
|
6283 hide_onmouseleave : 0,
|
|
|
6284 icons : true
|
|
|
6285 },
|
|
|
6286 _trigger : function (event_name) {
|
|
|
6287 $(document).triggerHandler("context_" + event_name + ".vakata", {
|
|
|
6288 "reference" : vakata_context.reference,
|
|
|
6289 "element" : vakata_context.element,
|
|
|
6290 "position" : {
|
|
|
6291 "x" : vakata_context.position_x,
|
|
|
6292 "y" : vakata_context.position_y
|
|
|
6293 }
|
|
|
6294 });
|
|
|
6295 },
|
|
|
6296 _execute : function (i) {
|
|
|
6297 i = vakata_context.items[i];
|
|
|
6298 return i && (!i._disabled || ($.isFunction(i._disabled) && !i._disabled({ "item" : i, "reference" : vakata_context.reference, "element" : vakata_context.element }))) && i.action ? i.action.call(null, {
|
|
|
6299 "item" : i,
|
|
|
6300 "reference" : vakata_context.reference,
|
|
|
6301 "element" : vakata_context.element,
|
|
|
6302 "position" : {
|
|
|
6303 "x" : vakata_context.position_x,
|
|
|
6304 "y" : vakata_context.position_y
|
|
|
6305 }
|
|
|
6306 }) : false;
|
|
|
6307 },
|
|
|
6308 _parse : function (o, is_callback) {
|
|
|
6309 if(!o) { return false; }
|
|
|
6310 if(!is_callback) {
|
|
|
6311 vakata_context.html = "";
|
|
|
6312 vakata_context.items = [];
|
|
|
6313 }
|
|
|
6314 var str = "",
|
|
|
6315 sep = false,
|
|
|
6316 tmp;
|
|
|
6317
|
|
|
6318 if(is_callback) { str += "<"+"ul>"; }
|
|
|
6319 $.each(o, function (i, val) {
|
|
|
6320 if(!val) { return true; }
|
|
|
6321 vakata_context.items.push(val);
|
|
|
6322 if(!sep && val.separator_before) {
|
|
|
6323 str += "<"+"li class='vakata-context-separator'><"+"a href='#' " + ($.vakata.context.settings.icons ? '' : 'style="margin-left:0px;"') + "> <"+"/a><"+"/li>";
|
|
|
6324 }
|
|
|
6325 sep = false;
|
|
|
6326 str += "<"+"li class='" + (val._class || "") + (val._disabled === true || ($.isFunction(val._disabled) && val._disabled({ "item" : val, "reference" : vakata_context.reference, "element" : vakata_context.element })) ? " vakata-contextmenu-disabled " : "") + "' "+(val.shortcut?" data-shortcut='"+val.shortcut+"' ":'')+">";
|
|
|
6327 str += "<"+"a href='#' rel='" + (vakata_context.items.length - 1) + "' " + (val.title ? "title='" + val.title + "'" : "") + ">";
|
|
|
6328 if($.vakata.context.settings.icons) {
|
|
|
6329 str += "<"+"i ";
|
|
|
6330 if(val.icon) {
|
|
|
6331 if(val.icon.indexOf("/") !== -1 || val.icon.indexOf(".") !== -1) { str += " style='background:url(\"" + val.icon + "\") center center no-repeat' "; }
|
|
|
6332 else { str += " class='" + val.icon + "' "; }
|
|
|
6333 }
|
|
|
6334 str += "><"+"/i><"+"span class='vakata-contextmenu-sep'> <"+"/span>";
|
|
|
6335 }
|
|
|
6336 str += ($.isFunction(val.label) ? val.label({ "item" : i, "reference" : vakata_context.reference, "element" : vakata_context.element }) : val.label) + (val.shortcut?' <span class="vakata-contextmenu-shortcut vakata-contextmenu-shortcut-'+val.shortcut+'">'+ (val.shortcut_label || '') +'</span>':'') + "<"+"/a>";
|
|
|
6337 if(val.submenu) {
|
|
|
6338 tmp = $.vakata.context._parse(val.submenu, true);
|
|
|
6339 if(tmp) { str += tmp; }
|
|
|
6340 }
|
|
|
6341 str += "<"+"/li>";
|
|
|
6342 if(val.separator_after) {
|
|
|
6343 str += "<"+"li class='vakata-context-separator'><"+"a href='#' " + ($.vakata.context.settings.icons ? '' : 'style="margin-left:0px;"') + "> <"+"/a><"+"/li>";
|
|
|
6344 sep = true;
|
|
|
6345 }
|
|
|
6346 });
|
|
|
6347 str = str.replace(/<li class\='vakata-context-separator'\><\/li\>$/,"");
|
|
|
6348 if(is_callback) { str += "</ul>"; }
|
|
|
6349 /**
|
|
|
6350 * triggered on the document when the contextmenu is parsed (HTML is built)
|
|
|
6351 * @event
|
|
|
6352 * @plugin contextmenu
|
|
|
6353 * @name context_parse.vakata
|
|
|
6354 * @param {jQuery} reference the element that was right clicked
|
|
|
6355 * @param {jQuery} element the DOM element of the menu itself
|
|
|
6356 * @param {Object} position the x & y coordinates of the menu
|
|
|
6357 */
|
|
|
6358 if(!is_callback) { vakata_context.html = str; $.vakata.context._trigger("parse"); }
|
|
|
6359 return str.length > 10 ? str : false;
|
|
|
6360 },
|
|
|
6361 _show_submenu : function (o) {
|
|
|
6362 o = $(o);
|
|
|
6363 if(!o.length || !o.children("ul").length) { return; }
|
|
|
6364 var e = o.children("ul"),
|
|
|
6365 xl = o.offset().left,
|
|
|
6366 x = xl + o.outerWidth(),
|
|
|
6367 y = o.offset().top,
|
|
|
6368 w = e.width(),
|
|
|
6369 h = e.height(),
|
|
|
6370 dw = $(window).width() + $(window).scrollLeft(),
|
|
|
6371 dh = $(window).height() + $(window).scrollTop();
|
|
|
6372 // може да се спести е една проверка - дали няма някой от класовете вече нагоре
|
|
|
6373 if(right_to_left) {
|
|
|
6374 o[x - (w + 10 + o.outerWidth()) < 0 ? "addClass" : "removeClass"]("vakata-context-left");
|
|
|
6375 }
|
|
|
6376 else {
|
|
|
6377 o[x + w > dw && xl > dw - x ? "addClass" : "removeClass"]("vakata-context-right");
|
|
|
6378 }
|
|
|
6379 if(y + h + 10 > dh) {
|
|
|
6380 e.css("bottom","-1px");
|
|
|
6381 }
|
|
|
6382
|
|
|
6383 //if does not fit - stick it to the side
|
|
|
6384 if (o.hasClass('vakata-context-right')) {
|
|
|
6385 if (xl < w) {
|
|
|
6386 e.css("margin-right", xl - w);
|
|
|
6387 }
|
|
|
6388 } else {
|
|
|
6389 if (dw - x < w) {
|
|
|
6390 e.css("margin-left", dw - x - w);
|
|
|
6391 }
|
|
|
6392 }
|
|
|
6393
|
|
|
6394 e.show();
|
|
|
6395 },
|
|
|
6396 show : function (reference, position, data) {
|
|
|
6397 var o, e, x, y, w, h, dw, dh, cond = true;
|
|
|
6398 if(vakata_context.element && vakata_context.element.length) {
|
|
|
6399 vakata_context.element.width('');
|
|
|
6400 }
|
|
|
6401 switch(cond) {
|
|
|
6402 case (!position && !reference):
|
|
|
6403 return false;
|
|
|
6404 case (!!position && !!reference):
|
|
|
6405 vakata_context.reference = reference;
|
|
|
6406 vakata_context.position_x = position.x;
|
|
|
6407 vakata_context.position_y = position.y;
|
|
|
6408 break;
|
|
|
6409 case (!position && !!reference):
|
|
|
6410 vakata_context.reference = reference;
|
|
|
6411 o = reference.offset();
|
|
|
6412 vakata_context.position_x = o.left + reference.outerHeight();
|
|
|
6413 vakata_context.position_y = o.top;
|
|
|
6414 break;
|
|
|
6415 case (!!position && !reference):
|
|
|
6416 vakata_context.position_x = position.x;
|
|
|
6417 vakata_context.position_y = position.y;
|
|
|
6418 break;
|
|
|
6419 }
|
|
|
6420 if(!!reference && !data && $(reference).data('vakata_contextmenu')) {
|
|
|
6421 data = $(reference).data('vakata_contextmenu');
|
|
|
6422 }
|
|
|
6423 if($.vakata.context._parse(data)) {
|
|
|
6424 vakata_context.element.html(vakata_context.html);
|
|
|
6425 }
|
|
|
6426 if(vakata_context.items.length) {
|
|
|
6427 vakata_context.element.appendTo("body");
|
|
|
6428 e = vakata_context.element;
|
|
|
6429 x = vakata_context.position_x;
|
|
|
6430 y = vakata_context.position_y;
|
|
|
6431 w = e.width();
|
|
|
6432 h = e.height();
|
|
|
6433 dw = $(window).width() + $(window).scrollLeft();
|
|
|
6434 dh = $(window).height() + $(window).scrollTop();
|
|
|
6435 if(right_to_left) {
|
|
|
6436 x -= (e.outerWidth() - $(reference).outerWidth());
|
|
|
6437 if(x < $(window).scrollLeft() + 20) {
|
|
|
6438 x = $(window).scrollLeft() + 20;
|
|
|
6439 }
|
|
|
6440 }
|
|
|
6441 if(x + w + 20 > dw) {
|
|
|
6442 x = dw - (w + 20);
|
|
|
6443 }
|
|
|
6444 if(y + h + 20 > dh) {
|
|
|
6445 y = dh - (h + 20);
|
|
|
6446 }
|
|
|
6447
|
|
|
6448 vakata_context.element
|
|
|
6449 .css({ "left" : x, "top" : y })
|
|
|
6450 .show()
|
|
|
6451 .find('a').first().focus().parent().addClass("vakata-context-hover");
|
|
|
6452 vakata_context.is_visible = true;
|
|
|
6453 /**
|
|
|
6454 * triggered on the document when the contextmenu is shown
|
|
|
6455 * @event
|
|
|
6456 * @plugin contextmenu
|
|
|
6457 * @name context_show.vakata
|
|
|
6458 * @param {jQuery} reference the element that was right clicked
|
|
|
6459 * @param {jQuery} element the DOM element of the menu itself
|
|
|
6460 * @param {Object} position the x & y coordinates of the menu
|
|
|
6461 */
|
|
|
6462 $.vakata.context._trigger("show");
|
|
|
6463 }
|
|
|
6464 },
|
|
|
6465 hide : function () {
|
|
|
6466 if(vakata_context.is_visible) {
|
|
|
6467 vakata_context.element.hide().find("ul").hide().end().find(':focus').blur().end().detach();
|
|
|
6468 vakata_context.is_visible = false;
|
|
|
6469 /**
|
|
|
6470 * triggered on the document when the contextmenu is hidden
|
|
|
6471 * @event
|
|
|
6472 * @plugin contextmenu
|
|
|
6473 * @name context_hide.vakata
|
|
|
6474 * @param {jQuery} reference the element that was right clicked
|
|
|
6475 * @param {jQuery} element the DOM element of the menu itself
|
|
|
6476 * @param {Object} position the x & y coordinates of the menu
|
|
|
6477 */
|
|
|
6478 $.vakata.context._trigger("hide");
|
|
|
6479 }
|
|
|
6480 }
|
|
|
6481 };
|
|
|
6482 $(function () {
|
|
|
6483 right_to_left = $("body").css("direction") === "rtl";
|
|
|
6484 var to = false;
|
|
|
6485
|
|
|
6486 vakata_context.element = $("<ul class='vakata-context'></ul>");
|
|
|
6487 vakata_context.element
|
|
|
6488 .on("mouseenter", "li", function (e) {
|
|
|
6489 e.stopImmediatePropagation();
|
|
|
6490
|
|
|
6491 if($.contains(this, e.relatedTarget)) {
|
|
|
6492 // премахнато заради delegate mouseleave по-долу
|
|
|
6493 // $(this).find(".vakata-context-hover").removeClass("vakata-context-hover");
|
|
|
6494 return;
|
|
|
6495 }
|
|
|
6496
|
|
|
6497 if(to) { clearTimeout(to); }
|
|
|
6498 vakata_context.element.find(".vakata-context-hover").removeClass("vakata-context-hover").end();
|
|
|
6499
|
|
|
6500 $(this)
|
|
|
6501 .siblings().find("ul").hide().end().end()
|
|
|
6502 .parentsUntil(".vakata-context", "li").addBack().addClass("vakata-context-hover");
|
|
|
6503 $.vakata.context._show_submenu(this);
|
|
|
6504 })
|
|
|
6505 // тестово - дали не натоварва?
|
|
|
6506 .on("mouseleave", "li", function (e) {
|
|
|
6507 if($.contains(this, e.relatedTarget)) { return; }
|
|
|
6508 $(this).find(".vakata-context-hover").addBack().removeClass("vakata-context-hover");
|
|
|
6509 })
|
|
|
6510 .on("mouseleave", function (e) {
|
|
|
6511 $(this).find(".vakata-context-hover").removeClass("vakata-context-hover");
|
|
|
6512 if($.vakata.context.settings.hide_onmouseleave) {
|
|
|
6513 to = setTimeout(
|
|
|
6514 (function (t) {
|
|
|
6515 return function () { $.vakata.context.hide(); };
|
|
|
6516 }(this)), $.vakata.context.settings.hide_onmouseleave);
|
|
|
6517 }
|
|
|
6518 })
|
|
|
6519 .on("click", "a", function (e) {
|
|
|
6520 e.preventDefault();
|
|
|
6521 //})
|
|
|
6522 //.on("mouseup", "a", function (e) {
|
|
|
6523 if(!$(this).blur().parent().hasClass("vakata-context-disabled") && $.vakata.context._execute($(this).attr("rel")) !== false) {
|
|
|
6524 $.vakata.context.hide();
|
|
|
6525 }
|
|
|
6526 })
|
|
|
6527 .on('keydown', 'a', function (e) {
|
|
|
6528 var o = null;
|
|
|
6529 switch(e.which) {
|
|
|
6530 case 13:
|
|
|
6531 case 32:
|
|
|
6532 e.type = "click";
|
|
|
6533 e.preventDefault();
|
|
|
6534 $(e.currentTarget).trigger(e);
|
|
|
6535 break;
|
|
|
6536 case 37:
|
|
|
6537 if(vakata_context.is_visible) {
|
|
|
6538 vakata_context.element.find(".vakata-context-hover").last().closest("li").first().find("ul").hide().find(".vakata-context-hover").removeClass("vakata-context-hover").end().end().children('a').focus();
|
|
|
6539 e.stopImmediatePropagation();
|
|
|
6540 e.preventDefault();
|
|
|
6541 }
|
|
|
6542 break;
|
|
|
6543 case 38:
|
|
|
6544 if(vakata_context.is_visible) {
|
|
|
6545 o = vakata_context.element.find("ul:visible").addBack().last().children(".vakata-context-hover").removeClass("vakata-context-hover").prevAll("li:not(.vakata-context-separator)").first();
|
|
|
6546 if(!o.length) { o = vakata_context.element.find("ul:visible").addBack().last().children("li:not(.vakata-context-separator)").last(); }
|
|
|
6547 o.addClass("vakata-context-hover").children('a').focus();
|
|
|
6548 e.stopImmediatePropagation();
|
|
|
6549 e.preventDefault();
|
|
|
6550 }
|
|
|
6551 break;
|
|
|
6552 case 39:
|
|
|
6553 if(vakata_context.is_visible) {
|
|
|
6554 vakata_context.element.find(".vakata-context-hover").last().children("ul").show().children("li:not(.vakata-context-separator)").removeClass("vakata-context-hover").first().addClass("vakata-context-hover").children('a').focus();
|
|
|
6555 e.stopImmediatePropagation();
|
|
|
6556 e.preventDefault();
|
|
|
6557 }
|
|
|
6558 break;
|
|
|
6559 case 40:
|
|
|
6560 if(vakata_context.is_visible) {
|
|
|
6561 o = vakata_context.element.find("ul:visible").addBack().last().children(".vakata-context-hover").removeClass("vakata-context-hover").nextAll("li:not(.vakata-context-separator)").first();
|
|
|
6562 if(!o.length) { o = vakata_context.element.find("ul:visible").addBack().last().children("li:not(.vakata-context-separator)").first(); }
|
|
|
6563 o.addClass("vakata-context-hover").children('a').focus();
|
|
|
6564 e.stopImmediatePropagation();
|
|
|
6565 e.preventDefault();
|
|
|
6566 }
|
|
|
6567 break;
|
|
|
6568 case 27:
|
|
|
6569 $.vakata.context.hide();
|
|
|
6570 e.preventDefault();
|
|
|
6571 break;
|
|
|
6572 default:
|
|
|
6573 //console.log(e.which);
|
|
|
6574 break;
|
|
|
6575 }
|
|
|
6576 })
|
|
|
6577 .on('keydown', function (e) {
|
|
|
6578 e.preventDefault();
|
|
|
6579 var a = vakata_context.element.find('.vakata-contextmenu-shortcut-' + e.which).parent();
|
|
|
6580 if(a.parent().not('.vakata-context-disabled')) {
|
|
|
6581 a.click();
|
|
|
6582 }
|
|
|
6583 });
|
|
|
6584
|
|
|
6585 $(document)
|
|
|
6586 .on("mousedown.vakata.jstree", function (e) {
|
|
|
6587 if(vakata_context.is_visible && vakata_context.element[0] !== e.target && !$.contains(vakata_context.element[0], e.target)) {
|
|
|
6588 $.vakata.context.hide();
|
|
|
6589 }
|
|
|
6590 })
|
|
|
6591 .on("context_show.vakata.jstree", function (e, data) {
|
|
|
6592 vakata_context.element.find("li:has(ul)").children("a").addClass("vakata-context-parent");
|
|
|
6593 if(right_to_left) {
|
|
|
6594 vakata_context.element.addClass("vakata-context-rtl").css("direction", "rtl");
|
|
|
6595 }
|
|
|
6596 // also apply a RTL class?
|
|
|
6597 vakata_context.element.find("ul").hide().end();
|
|
|
6598 });
|
|
|
6599 });
|
|
|
6600 }($));
|
|
|
6601 // $.jstree.defaults.plugins.push("contextmenu");
|
|
|
6602
|
|
|
6603
|
|
|
6604 /**
|
|
|
6605 * ### Drag'n'drop plugin
|
|
|
6606 *
|
|
|
6607 * Enables dragging and dropping of nodes in the tree, resulting in a move or copy operations.
|
|
|
6608 */
|
|
|
6609
|
|
|
6610 /**
|
|
|
6611 * stores all defaults for the drag'n'drop plugin
|
|
|
6612 * @name $.jstree.defaults.dnd
|
|
|
6613 * @plugin dnd
|
|
|
6614 */
|
|
|
6615 $.jstree.defaults.dnd = {
|
|
|
6616 /**
|
|
|
6617 * a boolean indicating if a copy should be possible while dragging (by pressint the meta key or Ctrl). Defaults to `true`.
|
|
|
6618 * @name $.jstree.defaults.dnd.copy
|
|
|
6619 * @plugin dnd
|
|
|
6620 */
|
|
|
6621 copy : true,
|
|
|
6622 /**
|
|
|
6623 * a number indicating how long a node should remain hovered while dragging to be opened. Defaults to `500`.
|
|
|
6624 * @name $.jstree.defaults.dnd.open_timeout
|
|
|
6625 * @plugin dnd
|
|
|
6626 */
|
|
|
6627 open_timeout : 500,
|
|
|
6628 /**
|
|
|
6629 * a function invoked each time a node is about to be dragged, invoked in the tree's scope and receives the nodes about to be dragged as an argument (array) and the event that started the drag - return `false` to prevent dragging
|
|
|
6630 * @name $.jstree.defaults.dnd.is_draggable
|
|
|
6631 * @plugin dnd
|
|
|
6632 */
|
|
|
6633 is_draggable : true,
|
|
|
6634 /**
|
|
|
6635 * a boolean indicating if checks should constantly be made while the user is dragging the node (as opposed to checking only on drop), default is `true`
|
|
|
6636 * @name $.jstree.defaults.dnd.check_while_dragging
|
|
|
6637 * @plugin dnd
|
|
|
6638 */
|
|
|
6639 check_while_dragging : true,
|
|
|
6640 /**
|
|
|
6641 * a boolean indicating if nodes from this tree should only be copied with dnd (as opposed to moved), default is `false`
|
|
|
6642 * @name $.jstree.defaults.dnd.always_copy
|
|
|
6643 * @plugin dnd
|
|
|
6644 */
|
|
|
6645 always_copy : false,
|
|
|
6646 /**
|
|
|
6647 * when dropping a node "inside", this setting indicates the position the node should go to - it can be an integer or a string: "first" (same as 0) or "last", default is `0`
|
|
|
6648 * @name $.jstree.defaults.dnd.inside_pos
|
|
|
6649 * @plugin dnd
|
|
|
6650 */
|
|
|
6651 inside_pos : 0,
|
|
|
6652 /**
|
|
|
6653 * when starting the drag on a node that is selected this setting controls if all selected nodes are dragged or only the single node, default is `true`, which means all selected nodes are dragged when the drag is started on a selected node
|
|
|
6654 * @name $.jstree.defaults.dnd.drag_selection
|
|
|
6655 * @plugin dnd
|
|
|
6656 */
|
|
|
6657 drag_selection : true,
|
|
|
6658 /**
|
|
|
6659 * controls whether dnd works on touch devices. If left as boolean true dnd will work the same as in desktop browsers, which in some cases may impair scrolling. If set to boolean false dnd will not work on touch devices. There is a special third option - string "selected" which means only selected nodes can be dragged on touch devices.
|
|
|
6660 * @name $.jstree.defaults.dnd.touch
|
|
|
6661 * @plugin dnd
|
|
|
6662 */
|
|
|
6663 touch : true,
|
|
|
6664 /**
|
|
|
6665 * controls whether items can be dropped anywhere on the node, not just on the anchor, by default only the node anchor is a valid drop target. Works best with the wholerow plugin. If enabled on mobile depending on the interface it might be hard for the user to cancel the drop, since the whole tree container will be a valid drop target.
|
|
|
6666 * @name $.jstree.defaults.dnd.large_drop_target
|
|
|
6667 * @plugin dnd
|
|
|
6668 */
|
|
|
6669 large_drop_target : false,
|
|
|
6670 /**
|
|
|
6671 * controls whether a drag can be initiated from any part of the node and not just the text/icon part, works best with the wholerow plugin. Keep in mind it can cause problems with tree scrolling on mobile depending on the interface - in that case set the touch option to "selected".
|
|
|
6672 * @name $.jstree.defaults.dnd.large_drag_target
|
|
|
6673 * @plugin dnd
|
|
|
6674 */
|
|
|
6675 large_drag_target : false,
|
|
|
6676 /**
|
|
|
6677 * controls whether use HTML5 dnd api instead of classical. That will allow better integration of dnd events with other HTML5 controls.
|
|
|
6678 * @reference http://caniuse.com/#feat=dragndrop
|
|
|
6679 * @name $.jstree.defaults.dnd.use_html5
|
|
|
6680 * @plugin dnd
|
|
|
6681 */
|
|
|
6682 use_html5: false
|
|
|
6683 };
|
|
|
6684 var drg, elm;
|
|
|
6685 // TODO: now check works by checking for each node individually, how about max_children, unique, etc?
|
|
|
6686 $.jstree.plugins.dnd = function (options, parent) {
|
|
|
6687 this.init = function (el, options) {
|
|
|
6688 parent.init.call(this, el, options);
|
|
|
6689 this.settings.dnd.use_html5 = this.settings.dnd.use_html5 && ('draggable' in document.createElement('span'));
|
|
|
6690 };
|
|
|
6691 this.bind = function () {
|
|
|
6692 parent.bind.call(this);
|
|
|
6693
|
|
|
6694 this.element
|
|
|
6695 .on(this.settings.dnd.use_html5 ? 'dragstart.jstree' : 'mousedown.jstree touchstart.jstree', this.settings.dnd.large_drag_target ? '.jstree-node' : '.jstree-anchor', $.proxy(function (e) {
|
|
|
6696 if(this.settings.dnd.large_drag_target && $(e.target).closest('.jstree-node')[0] !== e.currentTarget) {
|
|
|
6697 return true;
|
|
|
6698 }
|
|
|
6699 if(e.type === "touchstart" && (!this.settings.dnd.touch || (this.settings.dnd.touch === 'selected' && !$(e.currentTarget).closest('.jstree-node').children('.jstree-anchor').hasClass('jstree-clicked')))) {
|
|
|
6700 return true;
|
|
|
6701 }
|
|
|
6702 var obj = this.get_node(e.target),
|
|
|
6703 mlt = this.is_selected(obj) && this.settings.dnd.drag_selection ? this.get_top_selected().length : 1,
|
|
|
6704 txt = (mlt > 1 ? mlt + ' ' + this.get_string('nodes') : this.get_text(e.currentTarget));
|
|
|
6705 if(this.settings.core.force_text) {
|
|
|
6706 txt = $.vakata.html.escape(txt);
|
|
|
6707 }
|
|
|
6708 if(obj && obj.id && obj.id !== $.jstree.root && (e.which === 1 || e.type === "touchstart" || e.type === "dragstart") &&
|
|
|
6709 (this.settings.dnd.is_draggable === true || ($.isFunction(this.settings.dnd.is_draggable) && this.settings.dnd.is_draggable.call(this, (mlt > 1 ? this.get_top_selected(true) : [obj]), e)))
|
|
|
6710 ) {
|
|
|
6711 drg = { 'jstree' : true, 'origin' : this, 'obj' : this.get_node(obj,true), 'nodes' : mlt > 1 ? this.get_top_selected() : [obj.id] };
|
|
|
6712 elm = e.currentTarget;
|
|
|
6713 if (this.settings.dnd.use_html5) {
|
|
|
6714 $.vakata.dnd._trigger('start', e, { 'helper': $(), 'element': elm, 'data': drg });
|
|
|
6715 } else {
|
|
|
6716 this.element.trigger('mousedown.jstree');
|
|
|
6717 return $.vakata.dnd.start(e, drg, '<div id="jstree-dnd" class="jstree-' + this.get_theme() + ' jstree-' + this.get_theme() + '-' + this.get_theme_variant() + ' ' + ( this.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ) + '"><i class="jstree-icon jstree-er"></i>' + txt + '<ins class="jstree-copy" style="display:none;">+</ins></div>');
|
|
|
6718 }
|
|
|
6719 }
|
|
|
6720 }, this));
|
|
|
6721 if (this.settings.dnd.use_html5) {
|
|
|
6722 this.element
|
|
|
6723 .on('dragover.jstree', function (e) {
|
|
|
6724 e.preventDefault();
|
|
|
6725 $.vakata.dnd._trigger('move', e, { 'helper': $(), 'element': elm, 'data': drg });
|
|
|
6726 return false;
|
|
|
6727 })
|
|
|
6728 //.on('dragenter.jstree', this.settings.dnd.large_drop_target ? '.jstree-node' : '.jstree-anchor', $.proxy(function (e) {
|
|
|
6729 // e.preventDefault();
|
|
|
6730 // $.vakata.dnd._trigger('move', e, { 'helper': $(), 'element': elm, 'data': drg });
|
|
|
6731 // return false;
|
|
|
6732 // }, this))
|
|
|
6733 .on('drop.jstree', $.proxy(function (e) {
|
|
|
6734 e.preventDefault();
|
|
|
6735 $.vakata.dnd._trigger('stop', e, { 'helper': $(), 'element': elm, 'data': drg });
|
|
|
6736 return false;
|
|
|
6737 }, this));
|
|
|
6738 }
|
|
|
6739 };
|
|
|
6740 this.redraw_node = function(obj, deep, callback, force_render) {
|
|
|
6741 obj = parent.redraw_node.apply(this, arguments);
|
|
|
6742 if (obj && this.settings.dnd.use_html5) {
|
|
|
6743 if (this.settings.dnd.large_drag_target) {
|
|
|
6744 obj.setAttribute('draggable', true);
|
|
|
6745 } else {
|
|
|
6746 var i, j, tmp = null;
|
|
|
6747 for(i = 0, j = obj.childNodes.length; i < j; i++) {
|
|
|
6748 if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {
|
|
|
6749 tmp = obj.childNodes[i];
|
|
|
6750 break;
|
|
|
6751 }
|
|
|
6752 }
|
|
|
6753 if(tmp) {
|
|
|
6754 tmp.setAttribute('draggable', true);
|
|
|
6755 }
|
|
|
6756 }
|
|
|
6757 }
|
|
|
6758 return obj;
|
|
|
6759 };
|
|
|
6760 };
|
|
|
6761
|
|
|
6762 $(function() {
|
|
|
6763 // bind only once for all instances
|
|
|
6764 var lastmv = false,
|
|
|
6765 laster = false,
|
|
|
6766 lastev = false,
|
|
|
6767 opento = false,
|
|
|
6768 marker = $('<div id="jstree-marker"> </div>').hide(); //.appendTo('body');
|
|
|
6769
|
|
|
6770 $(document)
|
|
|
6771 .on('dnd_start.vakata.jstree', function (e, data) {
|
|
|
6772 lastmv = false;
|
|
|
6773 lastev = false;
|
|
|
6774 if(!data || !data.data || !data.data.jstree) { return; }
|
|
|
6775 marker.appendTo('body'); //.show();
|
|
|
6776 })
|
|
|
6777 .on('dnd_move.vakata.jstree', function (e, data) {
|
|
|
6778 var isDifferentNode = data.event.target !== lastev.target;
|
|
|
6779 if(opento) {
|
|
|
6780 if (!data.event || data.event.type !== 'dragover' || isDifferentNode) {
|
|
|
6781 clearTimeout(opento);
|
|
|
6782 }
|
|
|
6783 }
|
|
|
6784 if(!data || !data.data || !data.data.jstree) { return; }
|
|
|
6785
|
|
|
6786 // if we are hovering the marker image do nothing (can happen on "inside" drags)
|
|
|
6787 if(data.event.target.id && data.event.target.id === 'jstree-marker') {
|
|
|
6788 return;
|
|
|
6789 }
|
|
|
6790 lastev = data.event;
|
|
|
6791
|
|
|
6792 var ins = $.jstree.reference(data.event.target),
|
|
|
6793 ref = false,
|
|
|
6794 off = false,
|
|
|
6795 rel = false,
|
|
|
6796 tmp, l, t, h, p, i, o, ok, t1, t2, op, ps, pr, ip, tm, is_copy, pn;
|
|
|
6797 // if we are over an instance
|
|
|
6798 if(ins && ins._data && ins._data.dnd) {
|
|
|
6799 marker.attr('class', 'jstree-' + ins.get_theme() + ( ins.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ));
|
|
|
6800 is_copy = data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey)));
|
|
|
6801 data.helper
|
|
|
6802 .children().attr('class', 'jstree-' + ins.get_theme() + ' jstree-' + ins.get_theme() + '-' + ins.get_theme_variant() + ' ' + ( ins.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ))
|
|
|
6803 .find('.jstree-copy').first()[ is_copy ? 'show' : 'hide' ]();
|
|
|
6804
|
|
|
6805 // if are hovering the container itself add a new root node
|
|
|
6806 //console.log(data.event);
|
|
|
6807 if( (data.event.target === ins.element[0] || data.event.target === ins.get_container_ul()[0]) && ins.get_container_ul().children().length === 0) {
|
|
|
6808 ok = true;
|
|
|
6809 for(t1 = 0, t2 = data.data.nodes.length; t1 < t2; t1++) {
|
|
|
6810 ok = ok && ins.check( (data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey)) ) ? "copy_node" : "move_node"), (data.data.origin && data.data.origin !== ins ? data.data.origin.get_node(data.data.nodes[t1]) : data.data.nodes[t1]), $.jstree.root, 'last', { 'dnd' : true, 'ref' : ins.get_node($.jstree.root), 'pos' : 'i', 'origin' : data.data.origin, 'is_multi' : (data.data.origin && data.data.origin !== ins), 'is_foreign' : (!data.data.origin) });
|
|
|
6811 if(!ok) { break; }
|
|
|
6812 }
|
|
|
6813 if(ok) {
|
|
|
6814 lastmv = { 'ins' : ins, 'par' : $.jstree.root, 'pos' : 'last' };
|
|
|
6815 marker.hide();
|
|
|
6816 data.helper.find('.jstree-icon').first().removeClass('jstree-er').addClass('jstree-ok');
|
|
|
6817 if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {
|
|
|
6818 data.event.originalEvent.dataTransfer.dropEffect = is_copy ? 'copy' : 'move';
|
|
|
6819 }
|
|
|
6820 return;
|
|
|
6821 }
|
|
|
6822 }
|
|
|
6823 else {
|
|
|
6824 // if we are hovering a tree node
|
|
|
6825 ref = ins.settings.dnd.large_drop_target ? $(data.event.target).closest('.jstree-node').children('.jstree-anchor') : $(data.event.target).closest('.jstree-anchor');
|
|
|
6826 if(ref && ref.length && ref.parent().is('.jstree-closed, .jstree-open, .jstree-leaf')) {
|
|
|
6827 off = ref.offset();
|
|
|
6828 rel = (data.event.pageY !== undefined ? data.event.pageY : data.event.originalEvent.pageY) - off.top;
|
|
|
6829 h = ref.outerHeight();
|
|
|
6830 if(rel < h / 3) {
|
|
|
6831 o = ['b', 'i', 'a'];
|
|
|
6832 }
|
|
|
6833 else if(rel > h - h / 3) {
|
|
|
6834 o = ['a', 'i', 'b'];
|
|
|
6835 }
|
|
|
6836 else {
|
|
|
6837 o = rel > h / 2 ? ['i', 'a', 'b'] : ['i', 'b', 'a'];
|
|
|
6838 }
|
|
|
6839 $.each(o, function (j, v) {
|
|
|
6840 switch(v) {
|
|
|
6841 case 'b':
|
|
|
6842 l = off.left - 6;
|
|
|
6843 t = off.top;
|
|
|
6844 p = ins.get_parent(ref);
|
|
|
6845 i = ref.parent().index();
|
|
|
6846 break;
|
|
|
6847 case 'i':
|
|
|
6848 ip = ins.settings.dnd.inside_pos;
|
|
|
6849 tm = ins.get_node(ref.parent());
|
|
|
6850 l = off.left - 2;
|
|
|
6851 t = off.top + h / 2 + 1;
|
|
|
6852 p = tm.id;
|
|
|
6853 i = ip === 'first' ? 0 : (ip === 'last' ? tm.children.length : Math.min(ip, tm.children.length));
|
|
|
6854 break;
|
|
|
6855 case 'a':
|
|
|
6856 l = off.left - 6;
|
|
|
6857 t = off.top + h;
|
|
|
6858 p = ins.get_parent(ref);
|
|
|
6859 i = ref.parent().index() + 1;
|
|
|
6860 break;
|
|
|
6861 }
|
|
|
6862 ok = true;
|
|
|
6863 for(t1 = 0, t2 = data.data.nodes.length; t1 < t2; t1++) {
|
|
|
6864 op = data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey))) ? "copy_node" : "move_node";
|
|
|
6865 ps = i;
|
|
|
6866 if(op === "move_node" && v === 'a' && (data.data.origin && data.data.origin === ins) && p === ins.get_parent(data.data.nodes[t1])) {
|
|
|
6867 pr = ins.get_node(p);
|
|
|
6868 if(ps > $.inArray(data.data.nodes[t1], pr.children)) {
|
|
|
6869 ps -= 1;
|
|
|
6870 }
|
|
|
6871 }
|
|
|
6872 ok = ok && ( (ins && ins.settings && ins.settings.dnd && ins.settings.dnd.check_while_dragging === false) || ins.check(op, (data.data.origin && data.data.origin !== ins ? data.data.origin.get_node(data.data.nodes[t1]) : data.data.nodes[t1]), p, ps, { 'dnd' : true, 'ref' : ins.get_node(ref.parent()), 'pos' : v, 'origin' : data.data.origin, 'is_multi' : (data.data.origin && data.data.origin !== ins), 'is_foreign' : (!data.data.origin) }) );
|
|
|
6873 if(!ok) {
|
|
|
6874 if(ins && ins.last_error) { laster = ins.last_error(); }
|
|
|
6875 break;
|
|
|
6876 }
|
|
|
6877 }
|
|
|
6878 if(v === 'i' && ref.parent().is('.jstree-closed') && ins.settings.dnd.open_timeout) {
|
|
|
6879 if (!data.event || data.event.type !== 'dragover' || isDifferentNode) {
|
|
|
6880 if (opento) { clearTimeout(opento); }
|
|
|
6881 opento = setTimeout((function (x, z) { return function () { x.open_node(z); }; }(ins, ref)), ins.settings.dnd.open_timeout);
|
|
|
6882 }
|
|
|
6883 }
|
|
|
6884 if(ok) {
|
|
|
6885 pn = ins.get_node(p, true);
|
|
|
6886 if (!pn.hasClass('.jstree-dnd-parent')) {
|
|
|
6887 $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');
|
|
|
6888 pn.addClass('jstree-dnd-parent');
|
|
|
6889 }
|
|
|
6890 lastmv = { 'ins' : ins, 'par' : p, 'pos' : v === 'i' && ip === 'last' && i === 0 && !ins.is_loaded(tm) ? 'last' : i };
|
|
|
6891 marker.css({ 'left' : l + 'px', 'top' : t + 'px' }).show();
|
|
|
6892 data.helper.find('.jstree-icon').first().removeClass('jstree-er').addClass('jstree-ok');
|
|
|
6893 if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {
|
|
|
6894 data.event.originalEvent.dataTransfer.dropEffect = is_copy ? 'copy' : 'move';
|
|
|
6895 }
|
|
|
6896 laster = {};
|
|
|
6897 o = true;
|
|
|
6898 return false;
|
|
|
6899 }
|
|
|
6900 });
|
|
|
6901 if(o === true) { return; }
|
|
|
6902 }
|
|
|
6903 }
|
|
|
6904 }
|
|
|
6905 $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');
|
|
|
6906 lastmv = false;
|
|
|
6907 data.helper.find('.jstree-icon').removeClass('jstree-ok').addClass('jstree-er');
|
|
|
6908 if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {
|
|
|
6909 data.event.originalEvent.dataTransfer.dropEffect = 'none';
|
|
|
6910 }
|
|
|
6911 marker.hide();
|
|
|
6912 })
|
|
|
6913 .on('dnd_scroll.vakata.jstree', function (e, data) {
|
|
|
6914 if(!data || !data.data || !data.data.jstree) { return; }
|
|
|
6915 marker.hide();
|
|
|
6916 lastmv = false;
|
|
|
6917 lastev = false;
|
|
|
6918 data.helper.find('.jstree-icon').first().removeClass('jstree-ok').addClass('jstree-er');
|
|
|
6919 })
|
|
|
6920 .on('dnd_stop.vakata.jstree', function (e, data) {
|
|
|
6921 $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');
|
|
|
6922 if(opento) { clearTimeout(opento); }
|
|
|
6923 if(!data || !data.data || !data.data.jstree) { return; }
|
|
|
6924 marker.hide().detach();
|
|
|
6925 var i, j, nodes = [];
|
|
|
6926 if(lastmv) {
|
|
|
6927 for(i = 0, j = data.data.nodes.length; i < j; i++) {
|
|
|
6928 nodes[i] = data.data.origin ? data.data.origin.get_node(data.data.nodes[i]) : data.data.nodes[i];
|
|
|
6929 }
|
|
|
6930 lastmv.ins[ data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey))) ? 'copy_node' : 'move_node' ](nodes, lastmv.par, lastmv.pos, false, false, false, data.data.origin);
|
|
|
6931 }
|
|
|
6932 else {
|
|
|
6933 i = $(data.event.target).closest('.jstree');
|
|
|
6934 if(i.length && laster && laster.error && laster.error === 'check') {
|
|
|
6935 i = i.jstree(true);
|
|
|
6936 if(i) {
|
|
|
6937 i.settings.core.error.call(this, laster);
|
|
|
6938 }
|
|
|
6939 }
|
|
|
6940 }
|
|
|
6941 lastev = false;
|
|
|
6942 lastmv = false;
|
|
|
6943 })
|
|
|
6944 .on('keyup.jstree keydown.jstree', function (e, data) {
|
|
|
6945 data = $.vakata.dnd._get();
|
|
|
6946 if(data && data.data && data.data.jstree) {
|
|
|
6947 if (e.type === "keyup" && e.which === 27) {
|
|
|
6948 if (opento) { clearTimeout(opento); }
|
|
|
6949 lastmv = false;
|
|
|
6950 laster = false;
|
|
|
6951 lastev = false;
|
|
|
6952 opento = false;
|
|
|
6953 marker.hide().detach();
|
|
|
6954 $.vakata.dnd._clean();
|
|
|
6955 } else {
|
|
|
6956 data.helper.find('.jstree-copy').first()[ data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (e.metaKey || e.ctrlKey))) ? 'show' : 'hide' ]();
|
|
|
6957 if(lastev) {
|
|
|
6958 lastev.metaKey = e.metaKey;
|
|
|
6959 lastev.ctrlKey = e.ctrlKey;
|
|
|
6960 $.vakata.dnd._trigger('move', lastev);
|
|
|
6961 }
|
|
|
6962 }
|
|
|
6963 }
|
|
|
6964 });
|
|
|
6965 });
|
|
|
6966
|
|
|
6967 // helpers
|
|
|
6968 (function ($) {
|
|
|
6969 $.vakata.html = {
|
|
|
6970 div : $('<div />'),
|
|
|
6971 escape : function (str) {
|
|
|
6972 return $.vakata.html.div.text(str).html();
|
|
|
6973 },
|
|
|
6974 strip : function (str) {
|
|
|
6975 return $.vakata.html.div.empty().append($.parseHTML(str)).text();
|
|
|
6976 }
|
|
|
6977 };
|
|
|
6978 // private variable
|
|
|
6979 var vakata_dnd = {
|
|
|
6980 element : false,
|
|
|
6981 target : false,
|
|
|
6982 is_down : false,
|
|
|
6983 is_drag : false,
|
|
|
6984 helper : false,
|
|
|
6985 helper_w: 0,
|
|
|
6986 data : false,
|
|
|
6987 init_x : 0,
|
|
|
6988 init_y : 0,
|
|
|
6989 scroll_l: 0,
|
|
|
6990 scroll_t: 0,
|
|
|
6991 scroll_e: false,
|
|
|
6992 scroll_i: false,
|
|
|
6993 is_touch: false
|
|
|
6994 };
|
|
|
6995 $.vakata.dnd = {
|
|
|
6996 settings : {
|
|
|
6997 scroll_speed : 10,
|
|
|
6998 scroll_proximity : 20,
|
|
|
6999 helper_left : 5,
|
|
|
7000 helper_top : 10,
|
|
|
7001 threshold : 5,
|
|
|
7002 threshold_touch : 10
|
|
|
7003 },
|
|
|
7004 _trigger : function (event_name, e, data) {
|
|
|
7005 if (data === undefined) {
|
|
|
7006 data = $.vakata.dnd._get();
|
|
|
7007 }
|
|
|
7008 data.event = e;
|
|
|
7009 $(document).triggerHandler("dnd_" + event_name + ".vakata", data);
|
|
|
7010 },
|
|
|
7011 _get : function () {
|
|
|
7012 return {
|
|
|
7013 "data" : vakata_dnd.data,
|
|
|
7014 "element" : vakata_dnd.element,
|
|
|
7015 "helper" : vakata_dnd.helper
|
|
|
7016 };
|
|
|
7017 },
|
|
|
7018 _clean : function () {
|
|
|
7019 if(vakata_dnd.helper) { vakata_dnd.helper.remove(); }
|
|
|
7020 if(vakata_dnd.scroll_i) { clearInterval(vakata_dnd.scroll_i); vakata_dnd.scroll_i = false; }
|
|
|
7021 vakata_dnd = {
|
|
|
7022 element : false,
|
|
|
7023 target : false,
|
|
|
7024 is_down : false,
|
|
|
7025 is_drag : false,
|
|
|
7026 helper : false,
|
|
|
7027 helper_w: 0,
|
|
|
7028 data : false,
|
|
|
7029 init_x : 0,
|
|
|
7030 init_y : 0,
|
|
|
7031 scroll_l: 0,
|
|
|
7032 scroll_t: 0,
|
|
|
7033 scroll_e: false,
|
|
|
7034 scroll_i: false,
|
|
|
7035 is_touch: false
|
|
|
7036 };
|
|
|
7037 $(document).off("mousemove.vakata.jstree touchmove.vakata.jstree", $.vakata.dnd.drag);
|
|
|
7038 $(document).off("mouseup.vakata.jstree touchend.vakata.jstree", $.vakata.dnd.stop);
|
|
|
7039 },
|
|
|
7040 _scroll : function (init_only) {
|
|
|
7041 if(!vakata_dnd.scroll_e || (!vakata_dnd.scroll_l && !vakata_dnd.scroll_t)) {
|
|
|
7042 if(vakata_dnd.scroll_i) { clearInterval(vakata_dnd.scroll_i); vakata_dnd.scroll_i = false; }
|
|
|
7043 return false;
|
|
|
7044 }
|
|
|
7045 if(!vakata_dnd.scroll_i) {
|
|
|
7046 vakata_dnd.scroll_i = setInterval($.vakata.dnd._scroll, 100);
|
|
|
7047 return false;
|
|
|
7048 }
|
|
|
7049 if(init_only === true) { return false; }
|
|
|
7050
|
|
|
7051 var i = vakata_dnd.scroll_e.scrollTop(),
|
|
|
7052 j = vakata_dnd.scroll_e.scrollLeft();
|
|
|
7053 vakata_dnd.scroll_e.scrollTop(i + vakata_dnd.scroll_t * $.vakata.dnd.settings.scroll_speed);
|
|
|
7054 vakata_dnd.scroll_e.scrollLeft(j + vakata_dnd.scroll_l * $.vakata.dnd.settings.scroll_speed);
|
|
|
7055 if(i !== vakata_dnd.scroll_e.scrollTop() || j !== vakata_dnd.scroll_e.scrollLeft()) {
|
|
|
7056 /**
|
|
|
7057 * triggered on the document when a drag causes an element to scroll
|
|
|
7058 * @event
|
|
|
7059 * @plugin dnd
|
|
|
7060 * @name dnd_scroll.vakata
|
|
|
7061 * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start
|
|
|
7062 * @param {DOM} element the DOM element being dragged
|
|
|
7063 * @param {jQuery} helper the helper shown next to the mouse
|
|
|
7064 * @param {jQuery} event the element that is scrolling
|
|
|
7065 */
|
|
|
7066 $.vakata.dnd._trigger("scroll", vakata_dnd.scroll_e);
|
|
|
7067 }
|
|
|
7068 },
|
|
|
7069 start : function (e, data, html) {
|
|
|
7070 if(e.type === "touchstart" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {
|
|
|
7071 e.pageX = e.originalEvent.changedTouches[0].pageX;
|
|
|
7072 e.pageY = e.originalEvent.changedTouches[0].pageY;
|
|
|
7073 e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);
|
|
|
7074 }
|
|
|
7075 if(vakata_dnd.is_drag) { $.vakata.dnd.stop({}); }
|
|
|
7076 try {
|
|
|
7077 e.currentTarget.unselectable = "on";
|
|
|
7078 e.currentTarget.onselectstart = function() { return false; };
|
|
|
7079 if(e.currentTarget.style) {
|
|
|
7080 e.currentTarget.style.touchAction = "none";
|
|
|
7081 e.currentTarget.style.msTouchAction = "none";
|
|
|
7082 e.currentTarget.style.MozUserSelect = "none";
|
|
|
7083 }
|
|
|
7084 } catch(ignore) { }
|
|
|
7085 vakata_dnd.init_x = e.pageX;
|
|
|
7086 vakata_dnd.init_y = e.pageY;
|
|
|
7087 vakata_dnd.data = data;
|
|
|
7088 vakata_dnd.is_down = true;
|
|
|
7089 vakata_dnd.element = e.currentTarget;
|
|
|
7090 vakata_dnd.target = e.target;
|
|
|
7091 vakata_dnd.is_touch = e.type === "touchstart";
|
|
|
7092 if(html !== false) {
|
|
|
7093 vakata_dnd.helper = $("<div id='vakata-dnd'></div>").html(html).css({
|
|
|
7094 "display" : "block",
|
|
|
7095 "margin" : "0",
|
|
|
7096 "padding" : "0",
|
|
|
7097 "position" : "absolute",
|
|
|
7098 "top" : "-2000px",
|
|
|
7099 "lineHeight" : "16px",
|
|
|
7100 "zIndex" : "10000"
|
|
|
7101 });
|
|
|
7102 }
|
|
|
7103 $(document).on("mousemove.vakata.jstree touchmove.vakata.jstree", $.vakata.dnd.drag);
|
|
|
7104 $(document).on("mouseup.vakata.jstree touchend.vakata.jstree", $.vakata.dnd.stop);
|
|
|
7105 return false;
|
|
|
7106 },
|
|
|
7107 drag : function (e) {
|
|
|
7108 if(e.type === "touchmove" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {
|
|
|
7109 e.pageX = e.originalEvent.changedTouches[0].pageX;
|
|
|
7110 e.pageY = e.originalEvent.changedTouches[0].pageY;
|
|
|
7111 e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);
|
|
|
7112 }
|
|
|
7113 if(!vakata_dnd.is_down) { return; }
|
|
|
7114 if(!vakata_dnd.is_drag) {
|
|
|
7115 if(
|
|
|
7116 Math.abs(e.pageX - vakata_dnd.init_x) > (vakata_dnd.is_touch ? $.vakata.dnd.settings.threshold_touch : $.vakata.dnd.settings.threshold) ||
|
|
|
7117 Math.abs(e.pageY - vakata_dnd.init_y) > (vakata_dnd.is_touch ? $.vakata.dnd.settings.threshold_touch : $.vakata.dnd.settings.threshold)
|
|
|
7118 ) {
|
|
|
7119 if(vakata_dnd.helper) {
|
|
|
7120 vakata_dnd.helper.appendTo("body");
|
|
|
7121 vakata_dnd.helper_w = vakata_dnd.helper.outerWidth();
|
|
|
7122 }
|
|
|
7123 vakata_dnd.is_drag = true;
|
|
|
7124 $(vakata_dnd.target).one('click.vakata', false);
|
|
|
7125 /**
|
|
|
7126 * triggered on the document when a drag starts
|
|
|
7127 * @event
|
|
|
7128 * @plugin dnd
|
|
|
7129 * @name dnd_start.vakata
|
|
|
7130 * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start
|
|
|
7131 * @param {DOM} element the DOM element being dragged
|
|
|
7132 * @param {jQuery} helper the helper shown next to the mouse
|
|
|
7133 * @param {Object} event the event that caused the start (probably mousemove)
|
|
|
7134 */
|
|
|
7135 $.vakata.dnd._trigger("start", e);
|
|
|
7136 }
|
|
|
7137 else { return; }
|
|
|
7138 }
|
|
|
7139
|
|
|
7140 var d = false, w = false,
|
|
|
7141 dh = false, wh = false,
|
|
|
7142 dw = false, ww = false,
|
|
|
7143 dt = false, dl = false,
|
|
|
7144 ht = false, hl = false;
|
|
|
7145
|
|
|
7146 vakata_dnd.scroll_t = 0;
|
|
|
7147 vakata_dnd.scroll_l = 0;
|
|
|
7148 vakata_dnd.scroll_e = false;
|
|
|
7149 $($(e.target).parentsUntil("body").addBack().get().reverse())
|
|
|
7150 .filter(function () {
|
|
|
7151 return (/^auto|scroll$/).test($(this).css("overflow")) &&
|
|
|
7152 (this.scrollHeight > this.offsetHeight || this.scrollWidth > this.offsetWidth);
|
|
|
7153 })
|
|
|
7154 .each(function () {
|
|
|
7155 var t = $(this), o = t.offset();
|
|
|
7156 if(this.scrollHeight > this.offsetHeight) {
|
|
|
7157 if(o.top + t.height() - e.pageY < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = 1; }
|
|
|
7158 if(e.pageY - o.top < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = -1; }
|
|
|
7159 }
|
|
|
7160 if(this.scrollWidth > this.offsetWidth) {
|
|
|
7161 if(o.left + t.width() - e.pageX < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = 1; }
|
|
|
7162 if(e.pageX - o.left < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = -1; }
|
|
|
7163 }
|
|
|
7164 if(vakata_dnd.scroll_t || vakata_dnd.scroll_l) {
|
|
|
7165 vakata_dnd.scroll_e = $(this);
|
|
|
7166 return false;
|
|
|
7167 }
|
|
|
7168 });
|
|
|
7169
|
|
|
7170 if(!vakata_dnd.scroll_e) {
|
|
|
7171 d = $(document); w = $(window);
|
|
|
7172 dh = d.height(); wh = w.height();
|
|
|
7173 dw = d.width(); ww = w.width();
|
|
|
7174 dt = d.scrollTop(); dl = d.scrollLeft();
|
|
|
7175 if(dh > wh && e.pageY - dt < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = -1; }
|
|
|
7176 if(dh > wh && wh - (e.pageY - dt) < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = 1; }
|
|
|
7177 if(dw > ww && e.pageX - dl < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = -1; }
|
|
|
7178 if(dw > ww && ww - (e.pageX - dl) < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = 1; }
|
|
|
7179 if(vakata_dnd.scroll_t || vakata_dnd.scroll_l) {
|
|
|
7180 vakata_dnd.scroll_e = d;
|
|
|
7181 }
|
|
|
7182 }
|
|
|
7183 if(vakata_dnd.scroll_e) { $.vakata.dnd._scroll(true); }
|
|
|
7184
|
|
|
7185 if(vakata_dnd.helper) {
|
|
|
7186 ht = parseInt(e.pageY + $.vakata.dnd.settings.helper_top, 10);
|
|
|
7187 hl = parseInt(e.pageX + $.vakata.dnd.settings.helper_left, 10);
|
|
|
7188 if(dh && ht + 25 > dh) { ht = dh - 50; }
|
|
|
7189 if(dw && hl + vakata_dnd.helper_w > dw) { hl = dw - (vakata_dnd.helper_w + 2); }
|
|
|
7190 vakata_dnd.helper.css({
|
|
|
7191 left : hl + "px",
|
|
|
7192 top : ht + "px"
|
|
|
7193 });
|
|
|
7194 }
|
|
|
7195 /**
|
|
|
7196 * triggered on the document when a drag is in progress
|
|
|
7197 * @event
|
|
|
7198 * @plugin dnd
|
|
|
7199 * @name dnd_move.vakata
|
|
|
7200 * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start
|
|
|
7201 * @param {DOM} element the DOM element being dragged
|
|
|
7202 * @param {jQuery} helper the helper shown next to the mouse
|
|
|
7203 * @param {Object} event the event that caused this to trigger (most likely mousemove)
|
|
|
7204 */
|
|
|
7205 $.vakata.dnd._trigger("move", e);
|
|
|
7206 return false;
|
|
|
7207 },
|
|
|
7208 stop : function (e) {
|
|
|
7209 if(e.type === "touchend" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {
|
|
|
7210 e.pageX = e.originalEvent.changedTouches[0].pageX;
|
|
|
7211 e.pageY = e.originalEvent.changedTouches[0].pageY;
|
|
|
7212 e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);
|
|
|
7213 }
|
|
|
7214 if(vakata_dnd.is_drag) {
|
|
|
7215 /**
|
|
|
7216 * triggered on the document when a drag stops (the dragged element is dropped)
|
|
|
7217 * @event
|
|
|
7218 * @plugin dnd
|
|
|
7219 * @name dnd_stop.vakata
|
|
|
7220 * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start
|
|
|
7221 * @param {DOM} element the DOM element being dragged
|
|
|
7222 * @param {jQuery} helper the helper shown next to the mouse
|
|
|
7223 * @param {Object} event the event that caused the stop
|
|
|
7224 */
|
|
|
7225 if (e.target !== vakata_dnd.target) {
|
|
|
7226 $(vakata_dnd.target).off('click.vakata');
|
|
|
7227 }
|
|
|
7228 $.vakata.dnd._trigger("stop", e);
|
|
|
7229 }
|
|
|
7230 else {
|
|
|
7231 if(e.type === "touchend" && e.target === vakata_dnd.target) {
|
|
|
7232 var to = setTimeout(function () { $(e.target).click(); }, 100);
|
|
|
7233 $(e.target).one('click', function() { if(to) { clearTimeout(to); } });
|
|
|
7234 }
|
|
|
7235 }
|
|
|
7236 $.vakata.dnd._clean();
|
|
|
7237 return false;
|
|
|
7238 }
|
|
|
7239 };
|
|
|
7240 }($));
|
|
|
7241
|
|
|
7242 // include the dnd plugin by default
|
|
|
7243 // $.jstree.defaults.plugins.push("dnd");
|
|
|
7244
|
|
|
7245
|
|
|
7246 /**
|
|
|
7247 * ### Massload plugin
|
|
|
7248 *
|
|
|
7249 * Adds massload functionality to jsTree, so that multiple nodes can be loaded in a single request (only useful with lazy loading).
|
|
|
7250 */
|
|
|
7251
|
|
|
7252 /**
|
|
|
7253 * massload configuration
|
|
|
7254 *
|
|
|
7255 * It is possible to set this to a standard jQuery-like AJAX config.
|
|
|
7256 * In addition to the standard jQuery ajax options here you can supply functions for `data` and `url`, the functions will be run in the current instance's scope and a param will be passed indicating which node IDs need to be loaded, the return value of those functions will be used.
|
|
|
7257 *
|
|
|
7258 * You can also set this to a function, that function will receive the node IDs being loaded as argument and a second param which is a function (callback) which should be called with the result.
|
|
|
7259 *
|
|
|
7260 * Both the AJAX and the function approach rely on the same return value - an object where the keys are the node IDs, and the value is the children of that node as an array.
|
|
|
7261 *
|
|
|
7262 * {
|
|
|
7263 * "id1" : [{ "text" : "Child of ID1", "id" : "c1" }, { "text" : "Another child of ID1", "id" : "c2" }],
|
|
|
7264 * "id2" : [{ "text" : "Child of ID2", "id" : "c3" }]
|
|
|
7265 * }
|
|
|
7266 *
|
|
|
7267 * @name $.jstree.defaults.massload
|
|
|
7268 * @plugin massload
|
|
|
7269 */
|
|
|
7270 $.jstree.defaults.massload = null;
|
|
|
7271 $.jstree.plugins.massload = function (options, parent) {
|
|
|
7272 this.init = function (el, options) {
|
|
|
7273 this._data.massload = {};
|
|
|
7274 parent.init.call(this, el, options);
|
|
|
7275 };
|
|
|
7276 this._load_nodes = function (nodes, callback, is_callback, force_reload) {
|
|
|
7277 var s = this.settings.massload,
|
|
|
7278 nodesString = JSON.stringify(nodes),
|
|
|
7279 toLoad = [],
|
|
|
7280 m = this._model.data,
|
|
|
7281 i, j, dom;
|
|
|
7282 if (!is_callback) {
|
|
|
7283 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
7284 if(!m[nodes[i]] || ( (!m[nodes[i]].state.loaded && !m[nodes[i]].state.failed) || force_reload) ) {
|
|
|
7285 toLoad.push(nodes[i]);
|
|
|
7286 dom = this.get_node(nodes[i], true);
|
|
|
7287 if (dom && dom.length) {
|
|
|
7288 dom.addClass("jstree-loading").attr('aria-busy',true);
|
|
|
7289 }
|
|
|
7290 }
|
|
|
7291 }
|
|
|
7292 this._data.massload = {};
|
|
|
7293 if (toLoad.length) {
|
|
|
7294 if($.isFunction(s)) {
|
|
|
7295 return s.call(this, toLoad, $.proxy(function (data) {
|
|
|
7296 var i, j;
|
|
|
7297 if(data) {
|
|
|
7298 for(i in data) {
|
|
|
7299 if(data.hasOwnProperty(i)) {
|
|
|
7300 this._data.massload[i] = data[i];
|
|
|
7301 }
|
|
|
7302 }
|
|
|
7303 }
|
|
|
7304 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
7305 dom = this.get_node(nodes[i], true);
|
|
|
7306 if (dom && dom.length) {
|
|
|
7307 dom.removeClass("jstree-loading").attr('aria-busy',false);
|
|
|
7308 }
|
|
|
7309 }
|
|
|
7310 parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);
|
|
|
7311 }, this));
|
|
|
7312 }
|
|
|
7313 if(typeof s === 'object' && s && s.url) {
|
|
|
7314 s = $.extend(true, {}, s);
|
|
|
7315 if($.isFunction(s.url)) {
|
|
|
7316 s.url = s.url.call(this, toLoad);
|
|
|
7317 }
|
|
|
7318 if($.isFunction(s.data)) {
|
|
|
7319 s.data = s.data.call(this, toLoad);
|
|
|
7320 }
|
|
|
7321 return $.ajax(s)
|
|
|
7322 .done($.proxy(function (data,t,x) {
|
|
|
7323 var i, j;
|
|
|
7324 if(data) {
|
|
|
7325 for(i in data) {
|
|
|
7326 if(data.hasOwnProperty(i)) {
|
|
|
7327 this._data.massload[i] = data[i];
|
|
|
7328 }
|
|
|
7329 }
|
|
|
7330 }
|
|
|
7331 for(i = 0, j = nodes.length; i < j; i++) {
|
|
|
7332 dom = this.get_node(nodes[i], true);
|
|
|
7333 if (dom && dom.length) {
|
|
|
7334 dom.removeClass("jstree-loading").attr('aria-busy',false);
|
|
|
7335 }
|
|
|
7336 }
|
|
|
7337 parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);
|
|
|
7338 }, this))
|
|
|
7339 .fail($.proxy(function (f) {
|
|
|
7340 parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);
|
|
|
7341 }, this));
|
|
|
7342 }
|
|
|
7343 }
|
|
|
7344 }
|
|
|
7345 return parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);
|
|
|
7346 };
|
|
|
7347 this._load_node = function (obj, callback) {
|
|
|
7348 var data = this._data.massload[obj.id],
|
|
|
7349 rslt = null, dom;
|
|
|
7350 if(data) {
|
|
|
7351 rslt = this[typeof data === 'string' ? '_append_html_data' : '_append_json_data'](
|
|
|
7352 obj,
|
|
|
7353 typeof data === 'string' ? $($.parseHTML(data)).filter(function () { return this.nodeType !== 3; }) : data,
|
|
|
7354 function (status) { callback.call(this, status); }
|
|
|
7355 );
|
|
|
7356 dom = this.get_node(obj.id, true);
|
|
|
7357 if (dom && dom.length) {
|
|
|
7358 dom.removeClass("jstree-loading").attr('aria-busy',false);
|
|
|
7359 }
|
|
|
7360 delete this._data.massload[obj.id];
|
|
|
7361 return rslt;
|
|
|
7362 }
|
|
|
7363 return parent._load_node.call(this, obj, callback);
|
|
|
7364 };
|
|
|
7365 };
|
|
|
7366
|
|
|
7367 /**
|
|
|
7368 * ### Search plugin
|
|
|
7369 *
|
|
|
7370 * Adds search functionality to jsTree.
|
|
|
7371 */
|
|
|
7372
|
|
|
7373 /**
|
|
|
7374 * stores all defaults for the search plugin
|
|
|
7375 * @name $.jstree.defaults.search
|
|
|
7376 * @plugin search
|
|
|
7377 */
|
|
|
7378 $.jstree.defaults.search = {
|
|
|
7379 /**
|
|
|
7380 * a jQuery-like AJAX config, which jstree uses if a server should be queried for results.
|
|
|
7381 *
|
|
|
7382 * A `str` (which is the search string) parameter will be added with the request, an optional `inside` parameter will be added if the search is limited to a node id. The expected result is a JSON array with nodes that need to be opened so that matching nodes will be revealed.
|
|
|
7383 * Leave this setting as `false` to not query the server. You can also set this to a function, which will be invoked in the instance's scope and receive 3 parameters - the search string, the callback to call with the array of nodes to load, and the optional node ID to limit the search to
|
|
|
7384 * @name $.jstree.defaults.search.ajax
|
|
|
7385 * @plugin search
|
|
|
7386 */
|
|
|
7387 ajax : false,
|
|
|
7388 /**
|
|
|
7389 * Indicates if the search should be fuzzy or not (should `chnd3` match `child node 3`). Default is `false`.
|
|
|
7390 * @name $.jstree.defaults.search.fuzzy
|
|
|
7391 * @plugin search
|
|
|
7392 */
|
|
|
7393 fuzzy : false,
|
|
|
7394 /**
|
|
|
7395 * Indicates if the search should be case sensitive. Default is `false`.
|
|
|
7396 * @name $.jstree.defaults.search.case_sensitive
|
|
|
7397 * @plugin search
|
|
|
7398 */
|
|
|
7399 case_sensitive : false,
|
|
|
7400 /**
|
|
|
7401 * Indicates if the tree should be filtered (by default) to show only matching nodes (keep in mind this can be a heavy on large trees in old browsers).
|
|
|
7402 * This setting can be changed at runtime when calling the search method. Default is `false`.
|
|
|
7403 * @name $.jstree.defaults.search.show_only_matches
|
|
|
7404 * @plugin search
|
|
|
7405 */
|
|
|
7406 show_only_matches : false,
|
|
|
7407 /**
|
|
|
7408 * Indicates if the children of matched element are shown (when show_only_matches is true)
|
|
|
7409 * This setting can be changed at runtime when calling the search method. Default is `false`.
|
|
|
7410 * @name $.jstree.defaults.search.show_only_matches_children
|
|
|
7411 * @plugin search
|
|
|
7412 */
|
|
|
7413 show_only_matches_children : false,
|
|
|
7414 /**
|
|
|
7415 * Indicates if all nodes opened to reveal the search result, should be closed when the search is cleared or a new search is performed. Default is `true`.
|
|
|
7416 * @name $.jstree.defaults.search.close_opened_onclear
|
|
|
7417 * @plugin search
|
|
|
7418 */
|
|
|
7419 close_opened_onclear : true,
|
|
|
7420 /**
|
|
|
7421 * Indicates if only leaf nodes should be included in search results. Default is `false`.
|
|
|
7422 * @name $.jstree.defaults.search.search_leaves_only
|
|
|
7423 * @plugin search
|
|
|
7424 */
|
|
|
7425 search_leaves_only : false,
|
|
|
7426 /**
|
|
|
7427 * If set to a function it wil be called in the instance's scope with two arguments - search string and node (where node will be every node in the structure, so use with caution).
|
|
|
7428 * If the function returns a truthy value the node will be considered a match (it might not be displayed if search_only_leaves is set to true and the node is not a leaf). Default is `false`.
|
|
|
7429 * @name $.jstree.defaults.search.search_callback
|
|
|
7430 * @plugin search
|
|
|
7431 */
|
|
|
7432 search_callback : false
|
|
|
7433 };
|
|
|
7434
|
|
|
7435 $.jstree.plugins.search = function (options, parent) {
|
|
|
7436 this.bind = function () {
|
|
|
7437 parent.bind.call(this);
|
|
|
7438
|
|
|
7439 this._data.search.str = "";
|
|
|
7440 this._data.search.dom = $();
|
|
|
7441 this._data.search.res = [];
|
|
|
7442 this._data.search.opn = [];
|
|
|
7443 this._data.search.som = false;
|
|
|
7444 this._data.search.smc = false;
|
|
|
7445 this._data.search.hdn = [];
|
|
|
7446
|
|
|
7447 this.element
|
|
|
7448 .on("search.jstree", $.proxy(function (e, data) {
|
|
|
7449 if(this._data.search.som && data.res.length) {
|
|
|
7450 var m = this._model.data, i, j, p = [], k, l;
|
|
|
7451 for(i = 0, j = data.res.length; i < j; i++) {
|
|
|
7452 if(m[data.res[i]] && !m[data.res[i]].state.hidden) {
|
|
|
7453 p.push(data.res[i]);
|
|
|
7454 p = p.concat(m[data.res[i]].parents);
|
|
|
7455 if(this._data.search.smc) {
|
|
|
7456 for (k = 0, l = m[data.res[i]].children_d.length; k < l; k++) {
|
|
|
7457 if (m[m[data.res[i]].children_d[k]] && !m[m[data.res[i]].children_d[k]].state.hidden) {
|
|
|
7458 p.push(m[data.res[i]].children_d[k]);
|
|
|
7459 }
|
|
|
7460 }
|
|
|
7461 }
|
|
|
7462 }
|
|
|
7463 }
|
|
|
7464 p = $.vakata.array_remove_item($.vakata.array_unique(p), $.jstree.root);
|
|
|
7465 this._data.search.hdn = this.hide_all(true);
|
|
|
7466 this.show_node(p, true);
|
|
|
7467 this.redraw(true);
|
|
|
7468 }
|
|
|
7469 }, this))
|
|
|
7470 .on("clear_search.jstree", $.proxy(function (e, data) {
|
|
|
7471 if(this._data.search.som && data.res.length) {
|
|
|
7472 this.show_node(this._data.search.hdn, true);
|
|
|
7473 this.redraw(true);
|
|
|
7474 }
|
|
|
7475 }, this));
|
|
|
7476 };
|
|
|
7477 /**
|
|
|
7478 * used to search the tree nodes for a given string
|
|
|
7479 * @name search(str [, skip_async])
|
|
|
7480 * @param {String} str the search string
|
|
|
7481 * @param {Boolean} skip_async if set to true server will not be queried even if configured
|
|
|
7482 * @param {Boolean} show_only_matches if set to true only matching nodes will be shown (keep in mind this can be very slow on large trees or old browsers)
|
|
|
7483 * @param {mixed} inside an optional node to whose children to limit the search
|
|
|
7484 * @param {Boolean} append if set to true the results of this search are appended to the previous search
|
|
|
7485 * @plugin search
|
|
|
7486 * @trigger search.jstree
|
|
|
7487 */
|
|
|
7488 this.search = function (str, skip_async, show_only_matches, inside, append, show_only_matches_children) {
|
|
|
7489 if(str === false || $.trim(str.toString()) === "") {
|
|
|
7490 return this.clear_search();
|
|
|
7491 }
|
|
|
7492 inside = this.get_node(inside);
|
|
|
7493 inside = inside && inside.id ? inside.id : null;
|
|
|
7494 str = str.toString();
|
|
|
7495 var s = this.settings.search,
|
|
|
7496 a = s.ajax ? s.ajax : false,
|
|
|
7497 m = this._model.data,
|
|
|
7498 f = null,
|
|
|
7499 r = [],
|
|
|
7500 p = [], i, j;
|
|
|
7501 if(this._data.search.res.length && !append) {
|
|
|
7502 this.clear_search();
|
|
|
7503 }
|
|
|
7504 if(show_only_matches === undefined) {
|
|
|
7505 show_only_matches = s.show_only_matches;
|
|
|
7506 }
|
|
|
7507 if(show_only_matches_children === undefined) {
|
|
|
7508 show_only_matches_children = s.show_only_matches_children;
|
|
|
7509 }
|
|
|
7510 if(!skip_async && a !== false) {
|
|
|
7511 if($.isFunction(a)) {
|
|
|
7512 return a.call(this, str, $.proxy(function (d) {
|
|
|
7513 if(d && d.d) { d = d.d; }
|
|
|
7514 this._load_nodes(!$.isArray(d) ? [] : $.vakata.array_unique(d), function () {
|
|
|
7515 this.search(str, true, show_only_matches, inside, append, show_only_matches_children);
|
|
|
7516 });
|
|
|
7517 }, this), inside);
|
|
|
7518 }
|
|
|
7519 else {
|
|
|
7520 a = $.extend({}, a);
|
|
|
7521 if(!a.data) { a.data = {}; }
|
|
|
7522 a.data.str = str;
|
|
|
7523 if(inside) {
|
|
|
7524 a.data.inside = inside;
|
|
|
7525 }
|
|
|
7526 if (this._data.search.lastRequest) {
|
|
|
7527 this._data.search.lastRequest.abort();
|
|
|
7528 }
|
|
|
7529 this._data.search.lastRequest = $.ajax(a)
|
|
|
7530 .fail($.proxy(function () {
|
|
|
7531 this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'search', 'id' : 'search_01', 'reason' : 'Could not load search parents', 'data' : JSON.stringify(a) };
|
|
|
7532 this.settings.core.error.call(this, this._data.core.last_error);
|
|
|
7533 }, this))
|
|
|
7534 .done($.proxy(function (d) {
|
|
|
7535 if(d && d.d) { d = d.d; }
|
|
|
7536 this._load_nodes(!$.isArray(d) ? [] : $.vakata.array_unique(d), function () {
|
|
|
7537 this.search(str, true, show_only_matches, inside, append, show_only_matches_children);
|
|
|
7538 });
|
|
|
7539 }, this));
|
|
|
7540 return this._data.search.lastRequest;
|
|
|
7541 }
|
|
|
7542 }
|
|
|
7543 if(!append) {
|
|
|
7544 this._data.search.str = str;
|
|
|
7545 this._data.search.dom = $();
|
|
|
7546 this._data.search.res = [];
|
|
|
7547 this._data.search.opn = [];
|
|
|
7548 this._data.search.som = show_only_matches;
|
|
|
7549 this._data.search.smc = show_only_matches_children;
|
|
|
7550 }
|
|
|
7551
|
|
|
7552 f = new $.vakata.search(str, true, { caseSensitive : s.case_sensitive, fuzzy : s.fuzzy });
|
|
|
7553 $.each(m[inside ? inside : $.jstree.root].children_d, function (ii, i) {
|
|
|
7554 var v = m[i];
|
|
|
7555 if(v.text && !v.state.hidden && (!s.search_leaves_only || (v.state.loaded && v.children.length === 0)) && ( (s.search_callback && s.search_callback.call(this, str, v)) || (!s.search_callback && f.search(v.text).isMatch) ) ) {
|
|
|
7556 r.push(i);
|
|
|
7557 p = p.concat(v.parents);
|
|
|
7558 }
|
|
|
7559 });
|
|
|
7560 if(r.length) {
|
|
|
7561 p = $.vakata.array_unique(p);
|
|
|
7562 for(i = 0, j = p.length; i < j; i++) {
|
|
|
7563 if(p[i] !== $.jstree.root && m[p[i]] && this.open_node(p[i], null, 0) === true) {
|
|
|
7564 this._data.search.opn.push(p[i]);
|
|
|
7565 }
|
|
|
7566 }
|
|
|
7567 if(!append) {
|
|
|
7568 this._data.search.dom = $(this.element[0].querySelectorAll('#' + $.map(r, function (v) { return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&'); }).join(', #')));
|
|
|
7569 this._data.search.res = r;
|
|
|
7570 }
|
|
|
7571 else {
|
|
|
7572 this._data.search.dom = this._data.search.dom.add($(this.element[0].querySelectorAll('#' + $.map(r, function (v) { return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&'); }).join(', #'))));
|
|
|
7573 this._data.search.res = $.vakata.array_unique(this._data.search.res.concat(r));
|
|
|
7574 }
|
|
|
7575 this._data.search.dom.children(".jstree-anchor").addClass('jstree-search');
|
|
|
7576 }
|
|
|
7577 /**
|
|
|
7578 * triggered after search is complete
|
|
|
7579 * @event
|
|
|
7580 * @name search.jstree
|
|
|
7581 * @param {jQuery} nodes a jQuery collection of matching nodes
|
|
|
7582 * @param {String} str the search string
|
|
|
7583 * @param {Array} res a collection of objects represeing the matching nodes
|
|
|
7584 * @plugin search
|
|
|
7585 */
|
|
|
7586 this.trigger('search', { nodes : this._data.search.dom, str : str, res : this._data.search.res, show_only_matches : show_only_matches });
|
|
|
7587 };
|
|
|
7588 /**
|
|
|
7589 * used to clear the last search (removes classes and shows all nodes if filtering is on)
|
|
|
7590 * @name clear_search()
|
|
|
7591 * @plugin search
|
|
|
7592 * @trigger clear_search.jstree
|
|
|
7593 */
|
|
|
7594 this.clear_search = function () {
|
|
|
7595 if(this.settings.search.close_opened_onclear) {
|
|
|
7596 this.close_node(this._data.search.opn, 0);
|
|
|
7597 }
|
|
|
7598 /**
|
|
|
7599 * triggered after search is complete
|
|
|
7600 * @event
|
|
|
7601 * @name clear_search.jstree
|
|
|
7602 * @param {jQuery} nodes a jQuery collection of matching nodes (the result from the last search)
|
|
|
7603 * @param {String} str the search string (the last search string)
|
|
|
7604 * @param {Array} res a collection of objects represeing the matching nodes (the result from the last search)
|
|
|
7605 * @plugin search
|
|
|
7606 */
|
|
|
7607 this.trigger('clear_search', { 'nodes' : this._data.search.dom, str : this._data.search.str, res : this._data.search.res });
|
|
|
7608 if(this._data.search.res.length) {
|
|
|
7609 this._data.search.dom = $(this.element[0].querySelectorAll('#' + $.map(this._data.search.res, function (v) {
|
|
|
7610 return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&');
|
|
|
7611 }).join(', #')));
|
|
|
7612 this._data.search.dom.children(".jstree-anchor").removeClass("jstree-search");
|
|
|
7613 }
|
|
|
7614 this._data.search.str = "";
|
|
|
7615 this._data.search.res = [];
|
|
|
7616 this._data.search.opn = [];
|
|
|
7617 this._data.search.dom = $();
|
|
|
7618 };
|
|
|
7619
|
|
|
7620 this.redraw_node = function(obj, deep, callback, force_render) {
|
|
|
7621 obj = parent.redraw_node.apply(this, arguments);
|
|
|
7622 if(obj) {
|
|
|
7623 if($.inArray(obj.id, this._data.search.res) !== -1) {
|
|
|
7624 var i, j, tmp = null;
|
|
|
7625 for(i = 0, j = obj.childNodes.length; i < j; i++) {
|
|
|
7626 if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {
|
|
|
7627 tmp = obj.childNodes[i];
|
|
|
7628 break;
|
|
|
7629 }
|
|
|
7630 }
|
|
|
7631 if(tmp) {
|
|
|
7632 tmp.className += ' jstree-search';
|
|
|
7633 }
|
|
|
7634 }
|
|
|
7635 }
|
|
|
7636 return obj;
|
|
|
7637 };
|
|
|
7638 };
|
|
|
7639
|
|
|
7640 // helpers
|
|
|
7641 (function ($) {
|
|
|
7642 // from http://kiro.me/projects/fuse.html
|
|
|
7643 $.vakata.search = function(pattern, txt, options) {
|
|
|
7644 options = options || {};
|
|
|
7645 options = $.extend({}, $.vakata.search.defaults, options);
|
|
|
7646 if(options.fuzzy !== false) {
|
|
|
7647 options.fuzzy = true;
|
|
|
7648 }
|
|
|
7649 pattern = options.caseSensitive ? pattern : pattern.toLowerCase();
|
|
|
7650 var MATCH_LOCATION = options.location,
|
|
|
7651 MATCH_DISTANCE = options.distance,
|
|
|
7652 MATCH_THRESHOLD = options.threshold,
|
|
|
7653 patternLen = pattern.length,
|
|
|
7654 matchmask, pattern_alphabet, match_bitapScore, search;
|
|
|
7655 if(patternLen > 32) {
|
|
|
7656 options.fuzzy = false;
|
|
|
7657 }
|
|
|
7658 if(options.fuzzy) {
|
|
|
7659 matchmask = 1 << (patternLen - 1);
|
|
|
7660 pattern_alphabet = (function () {
|
|
|
7661 var mask = {},
|
|
|
7662 i = 0;
|
|
|
7663 for (i = 0; i < patternLen; i++) {
|
|
|
7664 mask[pattern.charAt(i)] = 0;
|
|
|
7665 }
|
|
|
7666 for (i = 0; i < patternLen; i++) {
|
|
|
7667 mask[pattern.charAt(i)] |= 1 << (patternLen - i - 1);
|
|
|
7668 }
|
|
|
7669 return mask;
|
|
|
7670 }());
|
|
|
7671 match_bitapScore = function (e, x) {
|
|
|
7672 var accuracy = e / patternLen,
|
|
|
7673 proximity = Math.abs(MATCH_LOCATION - x);
|
|
|
7674 if(!MATCH_DISTANCE) {
|
|
|
7675 return proximity ? 1.0 : accuracy;
|
|
|
7676 }
|
|
|
7677 return accuracy + (proximity / MATCH_DISTANCE);
|
|
|
7678 };
|
|
|
7679 }
|
|
|
7680 search = function (text) {
|
|
|
7681 text = options.caseSensitive ? text : text.toLowerCase();
|
|
|
7682 if(pattern === text || text.indexOf(pattern) !== -1) {
|
|
|
7683 return {
|
|
|
7684 isMatch: true,
|
|
|
7685 score: 0
|
|
|
7686 };
|
|
|
7687 }
|
|
|
7688 if(!options.fuzzy) {
|
|
|
7689 return {
|
|
|
7690 isMatch: false,
|
|
|
7691 score: 1
|
|
|
7692 };
|
|
|
7693 }
|
|
|
7694 var i, j,
|
|
|
7695 textLen = text.length,
|
|
|
7696 scoreThreshold = MATCH_THRESHOLD,
|
|
|
7697 bestLoc = text.indexOf(pattern, MATCH_LOCATION),
|
|
|
7698 binMin, binMid,
|
|
|
7699 binMax = patternLen + textLen,
|
|
|
7700 lastRd, start, finish, rd, charMatch,
|
|
|
7701 score = 1,
|
|
|
7702 locations = [];
|
|
|
7703 if (bestLoc !== -1) {
|
|
|
7704 scoreThreshold = Math.min(match_bitapScore(0, bestLoc), scoreThreshold);
|
|
|
7705 bestLoc = text.lastIndexOf(pattern, MATCH_LOCATION + patternLen);
|
|
|
7706 if (bestLoc !== -1) {
|
|
|
7707 scoreThreshold = Math.min(match_bitapScore(0, bestLoc), scoreThreshold);
|
|
|
7708 }
|
|
|
7709 }
|
|
|
7710 bestLoc = -1;
|
|
|
7711 for (i = 0; i < patternLen; i++) {
|
|
|
7712 binMin = 0;
|
|
|
7713 binMid = binMax;
|
|
|
7714 while (binMin < binMid) {
|
|
|
7715 if (match_bitapScore(i, MATCH_LOCATION + binMid) <= scoreThreshold) {
|
|
|
7716 binMin = binMid;
|
|
|
7717 } else {
|
|
|
7718 binMax = binMid;
|
|
|
7719 }
|
|
|
7720 binMid = Math.floor((binMax - binMin) / 2 + binMin);
|
|
|
7721 }
|
|
|
7722 binMax = binMid;
|
|
|
7723 start = Math.max(1, MATCH_LOCATION - binMid + 1);
|
|
|
7724 finish = Math.min(MATCH_LOCATION + binMid, textLen) + patternLen;
|
|
|
7725 rd = new Array(finish + 2);
|
|
|
7726 rd[finish + 1] = (1 << i) - 1;
|
|
|
7727 for (j = finish; j >= start; j--) {
|
|
|
7728 charMatch = pattern_alphabet[text.charAt(j - 1)];
|
|
|
7729 if (i === 0) {
|
|
|
7730 rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
|
|
|
7731 } else {
|
|
|
7732 rd[j] = ((rd[j + 1] << 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];
|
|
|
7733 }
|
|
|
7734 if (rd[j] & matchmask) {
|
|
|
7735 score = match_bitapScore(i, j - 1);
|
|
|
7736 if (score <= scoreThreshold) {
|
|
|
7737 scoreThreshold = score;
|
|
|
7738 bestLoc = j - 1;
|
|
|
7739 locations.push(bestLoc);
|
|
|
7740 if (bestLoc > MATCH_LOCATION) {
|
|
|
7741 start = Math.max(1, 2 * MATCH_LOCATION - bestLoc);
|
|
|
7742 } else {
|
|
|
7743 break;
|
|
|
7744 }
|
|
|
7745 }
|
|
|
7746 }
|
|
|
7747 }
|
|
|
7748 if (match_bitapScore(i + 1, MATCH_LOCATION) > scoreThreshold) {
|
|
|
7749 break;
|
|
|
7750 }
|
|
|
7751 lastRd = rd;
|
|
|
7752 }
|
|
|
7753 return {
|
|
|
7754 isMatch: bestLoc >= 0,
|
|
|
7755 score: score
|
|
|
7756 };
|
|
|
7757 };
|
|
|
7758 return txt === true ? { 'search' : search } : search(txt);
|
|
|
7759 };
|
|
|
7760 $.vakata.search.defaults = {
|
|
|
7761 location : 0,
|
|
|
7762 distance : 100,
|
|
|
7763 threshold : 0.6,
|
|
|
7764 fuzzy : false,
|
|
|
7765 caseSensitive : false
|
|
|
7766 };
|
|
|
7767 }($));
|
|
|
7768
|
|
|
7769 // include the search plugin by default
|
|
|
7770 // $.jstree.defaults.plugins.push("search");
|
|
|
7771
|
|
|
7772
|
|
|
7773 /**
|
|
|
7774 * ### Sort plugin
|
|
|
7775 *
|
|
|
7776 * Automatically sorts all siblings in the tree according to a sorting function.
|
|
|
7777 */
|
|
|
7778
|
|
|
7779 /**
|
|
|
7780 * the settings function used to sort the nodes.
|
|
|
7781 * It is executed in the tree's context, accepts two nodes as arguments and should return `1` or `-1`.
|
|
|
7782 * @name $.jstree.defaults.sort
|
|
|
7783 * @plugin sort
|
|
|
7784 */
|
|
|
7785 $.jstree.defaults.sort = function (a, b) {
|
|
|
7786 //return this.get_type(a) === this.get_type(b) ? (this.get_text(a) > this.get_text(b) ? 1 : -1) : this.get_type(a) >= this.get_type(b);
|
|
|
7787 return this.get_text(a) > this.get_text(b) ? 1 : -1;
|
|
|
7788 };
|
|
|
7789 $.jstree.plugins.sort = function (options, parent) {
|
|
|
7790 this.bind = function () {
|
|
|
7791 parent.bind.call(this);
|
|
|
7792 this.element
|
|
|
7793 .on("model.jstree", $.proxy(function (e, data) {
|
|
|
7794 this.sort(data.parent, true);
|
|
|
7795 }, this))
|
|
|
7796 .on("rename_node.jstree create_node.jstree", $.proxy(function (e, data) {
|
|
|
7797 this.sort(data.parent || data.node.parent, false);
|
|
|
7798 this.redraw_node(data.parent || data.node.parent, true);
|
|
|
7799 }, this))
|
|
|
7800 .on("move_node.jstree copy_node.jstree", $.proxy(function (e, data) {
|
|
|
7801 this.sort(data.parent, false);
|
|
|
7802 this.redraw_node(data.parent, true);
|
|
|
7803 }, this));
|
|
|
7804 };
|
|
|
7805 /**
|
|
|
7806 * used to sort a node's children
|
|
|
7807 * @private
|
|
|
7808 * @name sort(obj [, deep])
|
|
|
7809 * @param {mixed} obj the node
|
|
|
7810 * @param {Boolean} deep if set to `true` nodes are sorted recursively.
|
|
|
7811 * @plugin sort
|
|
|
7812 * @trigger search.jstree
|
|
|
7813 */
|
|
|
7814 this.sort = function (obj, deep) {
|
|
|
7815 var i, j;
|
|
|
7816 obj = this.get_node(obj);
|
|
|
7817 if(obj && obj.children && obj.children.length) {
|
|
|
7818 obj.children.sort($.proxy(this.settings.sort, this));
|
|
|
7819 if(deep) {
|
|
|
7820 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
7821 this.sort(obj.children_d[i], false);
|
|
|
7822 }
|
|
|
7823 }
|
|
|
7824 }
|
|
|
7825 };
|
|
|
7826 };
|
|
|
7827
|
|
|
7828 // include the sort plugin by default
|
|
|
7829 // $.jstree.defaults.plugins.push("sort");
|
|
|
7830
|
|
|
7831 /**
|
|
|
7832 * ### State plugin
|
|
|
7833 *
|
|
|
7834 * Saves the state of the tree (selected nodes, opened nodes) on the user's computer using available options (localStorage, cookies, etc)
|
|
|
7835 */
|
|
|
7836
|
|
|
7837 var to = false;
|
|
|
7838 /**
|
|
|
7839 * stores all defaults for the state plugin
|
|
|
7840 * @name $.jstree.defaults.state
|
|
|
7841 * @plugin state
|
|
|
7842 */
|
|
|
7843 $.jstree.defaults.state = {
|
|
|
7844 /**
|
|
|
7845 * A string for the key to use when saving the current tree (change if using multiple trees in your project). Defaults to `jstree`.
|
|
|
7846 * @name $.jstree.defaults.state.key
|
|
|
7847 * @plugin state
|
|
|
7848 */
|
|
|
7849 key : 'jstree',
|
|
|
7850 /**
|
|
|
7851 * A space separated list of events that trigger a state save. Defaults to `changed.jstree open_node.jstree close_node.jstree`.
|
|
|
7852 * @name $.jstree.defaults.state.events
|
|
|
7853 * @plugin state
|
|
|
7854 */
|
|
|
7855 events : 'changed.jstree open_node.jstree close_node.jstree check_node.jstree uncheck_node.jstree',
|
|
|
7856 /**
|
|
|
7857 * Time in milliseconds after which the state will expire. Defaults to 'false' meaning - no expire.
|
|
|
7858 * @name $.jstree.defaults.state.ttl
|
|
|
7859 * @plugin state
|
|
|
7860 */
|
|
|
7861 ttl : false,
|
|
|
7862 /**
|
|
|
7863 * A function that will be executed prior to restoring state with one argument - the state object. Can be used to clear unwanted parts of the state.
|
|
|
7864 * @name $.jstree.defaults.state.filter
|
|
|
7865 * @plugin state
|
|
|
7866 */
|
|
|
7867 filter : false,
|
|
|
7868 /**
|
|
|
7869 * Should loaded nodes be restored (setting this to true means that it is possible that the whole tree will be loaded for some users - use with caution). Defaults to `false`
|
|
|
7870 * @name $.jstree.defaults.state.preserve_loaded
|
|
|
7871 * @plugin state
|
|
|
7872 */
|
|
|
7873 preserve_loaded : false
|
|
|
7874 };
|
|
|
7875 $.jstree.plugins.state = function (options, parent) {
|
|
|
7876 this.bind = function () {
|
|
|
7877 parent.bind.call(this);
|
|
|
7878 var bind = $.proxy(function () {
|
|
|
7879 this.element.on(this.settings.state.events, $.proxy(function () {
|
|
|
7880 if(to) { clearTimeout(to); }
|
|
|
7881 to = setTimeout($.proxy(function () { this.save_state(); }, this), 100);
|
|
|
7882 }, this));
|
|
|
7883 /**
|
|
|
7884 * triggered when the state plugin is finished restoring the state (and immediately after ready if there is no state to restore).
|
|
|
7885 * @event
|
|
|
7886 * @name state_ready.jstree
|
|
|
7887 * @plugin state
|
|
|
7888 */
|
|
|
7889 this.trigger('state_ready');
|
|
|
7890 }, this);
|
|
|
7891 this.element
|
|
|
7892 .on("ready.jstree", $.proxy(function (e, data) {
|
|
|
7893 this.element.one("restore_state.jstree", bind);
|
|
|
7894 if(!this.restore_state()) { bind(); }
|
|
|
7895 }, this));
|
|
|
7896 };
|
|
|
7897 /**
|
|
|
7898 * save the state
|
|
|
7899 * @name save_state()
|
|
|
7900 * @plugin state
|
|
|
7901 */
|
|
|
7902 this.save_state = function () {
|
|
|
7903 var tm = this.get_state();
|
|
|
7904 if (!this.settings.state.preserve_loaded) {
|
|
|
7905 delete tm.core.loaded;
|
|
|
7906 }
|
|
|
7907 var st = { 'state' : tm, 'ttl' : this.settings.state.ttl, 'sec' : +(new Date()) };
|
|
|
7908 $.vakata.storage.set(this.settings.state.key, JSON.stringify(st));
|
|
|
7909 };
|
|
|
7910 /**
|
|
|
7911 * restore the state from the user's computer
|
|
|
7912 * @name restore_state()
|
|
|
7913 * @plugin state
|
|
|
7914 */
|
|
|
7915 this.restore_state = function () {
|
|
|
7916 var k = $.vakata.storage.get(this.settings.state.key);
|
|
|
7917 if(!!k) { try { k = JSON.parse(k); } catch(ex) { return false; } }
|
|
|
7918 if(!!k && k.ttl && k.sec && +(new Date()) - k.sec > k.ttl) { return false; }
|
|
|
7919 if(!!k && k.state) { k = k.state; }
|
|
|
7920 if(!!k && $.isFunction(this.settings.state.filter)) { k = this.settings.state.filter.call(this, k); }
|
|
|
7921 if(!!k) {
|
|
|
7922 if (!this.settings.state.preserve_loaded) {
|
|
|
7923 delete k.core.loaded;
|
|
|
7924 }
|
|
|
7925 this.element.one("set_state.jstree", function (e, data) { data.instance.trigger('restore_state', { 'state' : $.extend(true, {}, k) }); });
|
|
|
7926 this.set_state(k);
|
|
|
7927 return true;
|
|
|
7928 }
|
|
|
7929 return false;
|
|
|
7930 };
|
|
|
7931 /**
|
|
|
7932 * clear the state on the user's computer
|
|
|
7933 * @name clear_state()
|
|
|
7934 * @plugin state
|
|
|
7935 */
|
|
|
7936 this.clear_state = function () {
|
|
|
7937 return $.vakata.storage.del(this.settings.state.key);
|
|
|
7938 };
|
|
|
7939 };
|
|
|
7940
|
|
|
7941 (function ($, undefined) {
|
|
|
7942 $.vakata.storage = {
|
|
|
7943 // simply specifying the functions in FF throws an error
|
|
|
7944 set : function (key, val) { return window.localStorage.setItem(key, val); },
|
|
|
7945 get : function (key) { return window.localStorage.getItem(key); },
|
|
|
7946 del : function (key) { return window.localStorage.removeItem(key); }
|
|
|
7947 };
|
|
|
7948 }($));
|
|
|
7949
|
|
|
7950 // include the state plugin by default
|
|
|
7951 // $.jstree.defaults.plugins.push("state");
|
|
|
7952
|
|
|
7953 /**
|
|
|
7954 * ### Types plugin
|
|
|
7955 *
|
|
|
7956 * Makes it possible to add predefined types for groups of nodes, which make it possible to easily control nesting rules and icon for each group.
|
|
|
7957 */
|
|
|
7958
|
|
|
7959 /**
|
|
|
7960 * An object storing all types as key value pairs, where the key is the type name and the value is an object that could contain following keys (all optional).
|
|
|
7961 *
|
|
|
7962 * * `max_children` the maximum number of immediate children this node type can have. Do not specify or set to `-1` for unlimited.
|
|
|
7963 * * `max_depth` the maximum number of nesting this node type can have. A value of `1` would mean that the node can have children, but no grandchildren. Do not specify or set to `-1` for unlimited.
|
|
|
7964 * * `valid_children` an array of node type strings, that nodes of this type can have as children. Do not specify or set to `-1` for no limits.
|
|
|
7965 * * `icon` a string - can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class. Omit to use the default icon from your theme.
|
|
|
7966 * * `li_attr` an object of values which will be used to add HTML attributes on the resulting LI DOM node (merged with the node's own data)
|
|
|
7967 * * `a_attr` an object of values which will be used to add HTML attributes on the resulting A DOM node (merged with the node's own data)
|
|
|
7968 *
|
|
|
7969 * There are two predefined types:
|
|
|
7970 *
|
|
|
7971 * * `#` represents the root of the tree, for example `max_children` would control the maximum number of root nodes.
|
|
|
7972 * * `default` represents the default node - any settings here will be applied to all nodes that do not have a type specified.
|
|
|
7973 *
|
|
|
7974 * @name $.jstree.defaults.types
|
|
|
7975 * @plugin types
|
|
|
7976 */
|
|
|
7977 $.jstree.defaults.types = {
|
|
|
7978 'default' : {}
|
|
|
7979 };
|
|
|
7980 $.jstree.defaults.types[$.jstree.root] = {};
|
|
|
7981
|
|
|
7982 $.jstree.plugins.types = function (options, parent) {
|
|
|
7983 this.init = function (el, options) {
|
|
|
7984 var i, j;
|
|
|
7985 if(options && options.types && options.types['default']) {
|
|
|
7986 for(i in options.types) {
|
|
|
7987 if(i !== "default" && i !== $.jstree.root && options.types.hasOwnProperty(i)) {
|
|
|
7988 for(j in options.types['default']) {
|
|
|
7989 if(options.types['default'].hasOwnProperty(j) && options.types[i][j] === undefined) {
|
|
|
7990 options.types[i][j] = options.types['default'][j];
|
|
|
7991 }
|
|
|
7992 }
|
|
|
7993 }
|
|
|
7994 }
|
|
|
7995 }
|
|
|
7996 parent.init.call(this, el, options);
|
|
|
7997 this._model.data[$.jstree.root].type = $.jstree.root;
|
|
|
7998 };
|
|
|
7999 this.refresh = function (skip_loading, forget_state) {
|
|
|
8000 parent.refresh.call(this, skip_loading, forget_state);
|
|
|
8001 this._model.data[$.jstree.root].type = $.jstree.root;
|
|
|
8002 };
|
|
|
8003 this.bind = function () {
|
|
|
8004 this.element
|
|
|
8005 .on('model.jstree', $.proxy(function (e, data) {
|
|
|
8006 var m = this._model.data,
|
|
|
8007 dpc = data.nodes,
|
|
|
8008 t = this.settings.types,
|
|
|
8009 i, j, c = 'default', k;
|
|
|
8010 for(i = 0, j = dpc.length; i < j; i++) {
|
|
|
8011 c = 'default';
|
|
|
8012 if(m[dpc[i]].original && m[dpc[i]].original.type && t[m[dpc[i]].original.type]) {
|
|
|
8013 c = m[dpc[i]].original.type;
|
|
|
8014 }
|
|
|
8015 if(m[dpc[i]].data && m[dpc[i]].data.jstree && m[dpc[i]].data.jstree.type && t[m[dpc[i]].data.jstree.type]) {
|
|
|
8016 c = m[dpc[i]].data.jstree.type;
|
|
|
8017 }
|
|
|
8018 m[dpc[i]].type = c;
|
|
|
8019 if(m[dpc[i]].icon === true && t[c].icon !== undefined) {
|
|
|
8020 m[dpc[i]].icon = t[c].icon;
|
|
|
8021 }
|
|
|
8022 if(t[c].li_attr !== undefined && typeof t[c].li_attr === 'object') {
|
|
|
8023 for (k in t[c].li_attr) {
|
|
|
8024 if (t[c].li_attr.hasOwnProperty(k)) {
|
|
|
8025 if (k === 'id') {
|
|
|
8026 continue;
|
|
|
8027 }
|
|
|
8028 else if (m[dpc[i]].li_attr[k] === undefined) {
|
|
|
8029 m[dpc[i]].li_attr[k] = t[c].li_attr[k];
|
|
|
8030 }
|
|
|
8031 else if (k === 'class') {
|
|
|
8032 m[dpc[i]].li_attr['class'] = t[c].li_attr['class'] + ' ' + m[dpc[i]].li_attr['class'];
|
|
|
8033 }
|
|
|
8034 }
|
|
|
8035 }
|
|
|
8036 }
|
|
|
8037 if(t[c].a_attr !== undefined && typeof t[c].a_attr === 'object') {
|
|
|
8038 for (k in t[c].a_attr) {
|
|
|
8039 if (t[c].a_attr.hasOwnProperty(k)) {
|
|
|
8040 if (k === 'id') {
|
|
|
8041 continue;
|
|
|
8042 }
|
|
|
8043 else if (m[dpc[i]].a_attr[k] === undefined) {
|
|
|
8044 m[dpc[i]].a_attr[k] = t[c].a_attr[k];
|
|
|
8045 }
|
|
|
8046 else if (k === 'href' && m[dpc[i]].a_attr[k] === '#') {
|
|
|
8047 m[dpc[i]].a_attr['href'] = t[c].a_attr['href'];
|
|
|
8048 }
|
|
|
8049 else if (k === 'class') {
|
|
|
8050 m[dpc[i]].a_attr['class'] = t[c].a_attr['class'] + ' ' + m[dpc[i]].a_attr['class'];
|
|
|
8051 }
|
|
|
8052 }
|
|
|
8053 }
|
|
|
8054 }
|
|
|
8055 }
|
|
|
8056 m[$.jstree.root].type = $.jstree.root;
|
|
|
8057 }, this));
|
|
|
8058 parent.bind.call(this);
|
|
|
8059 };
|
|
|
8060 this.get_json = function (obj, options, flat) {
|
|
|
8061 var i, j,
|
|
|
8062 m = this._model.data,
|
|
|
8063 opt = options ? $.extend(true, {}, options, {no_id:false}) : {},
|
|
|
8064 tmp = parent.get_json.call(this, obj, opt, flat);
|
|
|
8065 if(tmp === false) { return false; }
|
|
|
8066 if($.isArray(tmp)) {
|
|
|
8067 for(i = 0, j = tmp.length; i < j; i++) {
|
|
|
8068 tmp[i].type = tmp[i].id && m[tmp[i].id] && m[tmp[i].id].type ? m[tmp[i].id].type : "default";
|
|
|
8069 if(options && options.no_id) {
|
|
|
8070 delete tmp[i].id;
|
|
|
8071 if(tmp[i].li_attr && tmp[i].li_attr.id) {
|
|
|
8072 delete tmp[i].li_attr.id;
|
|
|
8073 }
|
|
|
8074 if(tmp[i].a_attr && tmp[i].a_attr.id) {
|
|
|
8075 delete tmp[i].a_attr.id;
|
|
|
8076 }
|
|
|
8077 }
|
|
|
8078 }
|
|
|
8079 }
|
|
|
8080 else {
|
|
|
8081 tmp.type = tmp.id && m[tmp.id] && m[tmp.id].type ? m[tmp.id].type : "default";
|
|
|
8082 if(options && options.no_id) {
|
|
|
8083 tmp = this._delete_ids(tmp);
|
|
|
8084 }
|
|
|
8085 }
|
|
|
8086 return tmp;
|
|
|
8087 };
|
|
|
8088 this._delete_ids = function (tmp) {
|
|
|
8089 if($.isArray(tmp)) {
|
|
|
8090 for(var i = 0, j = tmp.length; i < j; i++) {
|
|
|
8091 tmp[i] = this._delete_ids(tmp[i]);
|
|
|
8092 }
|
|
|
8093 return tmp;
|
|
|
8094 }
|
|
|
8095 delete tmp.id;
|
|
|
8096 if(tmp.li_attr && tmp.li_attr.id) {
|
|
|
8097 delete tmp.li_attr.id;
|
|
|
8098 }
|
|
|
8099 if(tmp.a_attr && tmp.a_attr.id) {
|
|
|
8100 delete tmp.a_attr.id;
|
|
|
8101 }
|
|
|
8102 if(tmp.children && $.isArray(tmp.children)) {
|
|
|
8103 tmp.children = this._delete_ids(tmp.children);
|
|
|
8104 }
|
|
|
8105 return tmp;
|
|
|
8106 };
|
|
|
8107 this.check = function (chk, obj, par, pos, more) {
|
|
|
8108 if(parent.check.call(this, chk, obj, par, pos, more) === false) { return false; }
|
|
|
8109 obj = obj && obj.id ? obj : this.get_node(obj);
|
|
|
8110 par = par && par.id ? par : this.get_node(par);
|
|
|
8111 var m = obj && obj.id ? (more && more.origin ? more.origin : $.jstree.reference(obj.id)) : null, tmp, d, i, j;
|
|
|
8112 m = m && m._model && m._model.data ? m._model.data : null;
|
|
|
8113 switch(chk) {
|
|
|
8114 case "create_node":
|
|
|
8115 case "move_node":
|
|
|
8116 case "copy_node":
|
|
|
8117 if(chk !== 'move_node' || $.inArray(obj.id, par.children) === -1) {
|
|
|
8118 tmp = this.get_rules(par);
|
|
|
8119 if(tmp.max_children !== undefined && tmp.max_children !== -1 && tmp.max_children === par.children.length) {
|
|
|
8120 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_01', 'reason' : 'max_children prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8121 return false;
|
|
|
8122 }
|
|
|
8123 if(tmp.valid_children !== undefined && tmp.valid_children !== -1 && $.inArray((obj.type || 'default'), tmp.valid_children) === -1) {
|
|
|
8124 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_02', 'reason' : 'valid_children prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8125 return false;
|
|
|
8126 }
|
|
|
8127 if(m && obj.children_d && obj.parents) {
|
|
|
8128 d = 0;
|
|
|
8129 for(i = 0, j = obj.children_d.length; i < j; i++) {
|
|
|
8130 d = Math.max(d, m[obj.children_d[i]].parents.length);
|
|
|
8131 }
|
|
|
8132 d = d - obj.parents.length + 1;
|
|
|
8133 }
|
|
|
8134 if(d <= 0 || d === undefined) { d = 1; }
|
|
|
8135 do {
|
|
|
8136 if(tmp.max_depth !== undefined && tmp.max_depth !== -1 && tmp.max_depth < d) {
|
|
|
8137 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_03', 'reason' : 'max_depth prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8138 return false;
|
|
|
8139 }
|
|
|
8140 par = this.get_node(par.parent);
|
|
|
8141 tmp = this.get_rules(par);
|
|
|
8142 d++;
|
|
|
8143 } while(par);
|
|
|
8144 }
|
|
|
8145 break;
|
|
|
8146 }
|
|
|
8147 return true;
|
|
|
8148 };
|
|
|
8149 /**
|
|
|
8150 * used to retrieve the type settings object for a node
|
|
|
8151 * @name get_rules(obj)
|
|
|
8152 * @param {mixed} obj the node to find the rules for
|
|
|
8153 * @return {Object}
|
|
|
8154 * @plugin types
|
|
|
8155 */
|
|
|
8156 this.get_rules = function (obj) {
|
|
|
8157 obj = this.get_node(obj);
|
|
|
8158 if(!obj) { return false; }
|
|
|
8159 var tmp = this.get_type(obj, true);
|
|
|
8160 if(tmp.max_depth === undefined) { tmp.max_depth = -1; }
|
|
|
8161 if(tmp.max_children === undefined) { tmp.max_children = -1; }
|
|
|
8162 if(tmp.valid_children === undefined) { tmp.valid_children = -1; }
|
|
|
8163 return tmp;
|
|
|
8164 };
|
|
|
8165 /**
|
|
|
8166 * used to retrieve the type string or settings object for a node
|
|
|
8167 * @name get_type(obj [, rules])
|
|
|
8168 * @param {mixed} obj the node to find the rules for
|
|
|
8169 * @param {Boolean} rules if set to `true` instead of a string the settings object will be returned
|
|
|
8170 * @return {String|Object}
|
|
|
8171 * @plugin types
|
|
|
8172 */
|
|
|
8173 this.get_type = function (obj, rules) {
|
|
|
8174 obj = this.get_node(obj);
|
|
|
8175 return (!obj) ? false : ( rules ? $.extend({ 'type' : obj.type }, this.settings.types[obj.type]) : obj.type);
|
|
|
8176 };
|
|
|
8177 /**
|
|
|
8178 * used to change a node's type
|
|
|
8179 * @name set_type(obj, type)
|
|
|
8180 * @param {mixed} obj the node to change
|
|
|
8181 * @param {String} type the new type
|
|
|
8182 * @plugin types
|
|
|
8183 */
|
|
|
8184 this.set_type = function (obj, type) {
|
|
|
8185 var m = this._model.data, t, t1, t2, old_type, old_icon, k, d, a;
|
|
|
8186 if($.isArray(obj)) {
|
|
|
8187 obj = obj.slice();
|
|
|
8188 for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {
|
|
|
8189 this.set_type(obj[t1], type);
|
|
|
8190 }
|
|
|
8191 return true;
|
|
|
8192 }
|
|
|
8193 t = this.settings.types;
|
|
|
8194 obj = this.get_node(obj);
|
|
|
8195 if(!t[type] || !obj) { return false; }
|
|
|
8196 d = this.get_node(obj, true);
|
|
|
8197 if (d && d.length) {
|
|
|
8198 a = d.children('.jstree-anchor');
|
|
|
8199 }
|
|
|
8200 old_type = obj.type;
|
|
|
8201 old_icon = this.get_icon(obj);
|
|
|
8202 obj.type = type;
|
|
|
8203 if(old_icon === true || !t[old_type] || (t[old_type].icon !== undefined && old_icon === t[old_type].icon)) {
|
|
|
8204 this.set_icon(obj, t[type].icon !== undefined ? t[type].icon : true);
|
|
|
8205 }
|
|
|
8206
|
|
|
8207 // remove old type props
|
|
|
8208 if(t[old_type] && t[old_type].li_attr !== undefined && typeof t[old_type].li_attr === 'object') {
|
|
|
8209 for (k in t[old_type].li_attr) {
|
|
|
8210 if (t[old_type].li_attr.hasOwnProperty(k)) {
|
|
|
8211 if (k === 'id') {
|
|
|
8212 continue;
|
|
|
8213 }
|
|
|
8214 else if (k === 'class') {
|
|
|
8215 m[obj.id].li_attr['class'] = (m[obj.id].li_attr['class'] || '').replace(t[old_type].li_attr[k], '');
|
|
|
8216 if (d) { d.removeClass(t[old_type].li_attr[k]); }
|
|
|
8217 }
|
|
|
8218 else if (m[obj.id].li_attr[k] === t[old_type].li_attr[k]) {
|
|
|
8219 m[obj.id].li_attr[k] = null;
|
|
|
8220 if (d) { d.removeAttr(k); }
|
|
|
8221 }
|
|
|
8222 }
|
|
|
8223 }
|
|
|
8224 }
|
|
|
8225 if(t[old_type] && t[old_type].a_attr !== undefined && typeof t[old_type].a_attr === 'object') {
|
|
|
8226 for (k in t[old_type].a_attr) {
|
|
|
8227 if (t[old_type].a_attr.hasOwnProperty(k)) {
|
|
|
8228 if (k === 'id') {
|
|
|
8229 continue;
|
|
|
8230 }
|
|
|
8231 else if (k === 'class') {
|
|
|
8232 m[obj.id].a_attr['class'] = (m[obj.id].a_attr['class'] || '').replace(t[old_type].a_attr[k], '');
|
|
|
8233 if (a) { a.removeClass(t[old_type].a_attr[k]); }
|
|
|
8234 }
|
|
|
8235 else if (m[obj.id].a_attr[k] === t[old_type].a_attr[k]) {
|
|
|
8236 if (k === 'href') {
|
|
|
8237 m[obj.id].a_attr[k] = '#';
|
|
|
8238 if (a) { a.attr('href', '#'); }
|
|
|
8239 }
|
|
|
8240 else {
|
|
|
8241 delete m[obj.id].a_attr[k];
|
|
|
8242 if (a) { a.removeAttr(k); }
|
|
|
8243 }
|
|
|
8244 }
|
|
|
8245 }
|
|
|
8246 }
|
|
|
8247 }
|
|
|
8248
|
|
|
8249 // add new props
|
|
|
8250 if(t[type].li_attr !== undefined && typeof t[type].li_attr === 'object') {
|
|
|
8251 for (k in t[type].li_attr) {
|
|
|
8252 if (t[type].li_attr.hasOwnProperty(k)) {
|
|
|
8253 if (k === 'id') {
|
|
|
8254 continue;
|
|
|
8255 }
|
|
|
8256 else if (m[obj.id].li_attr[k] === undefined) {
|
|
|
8257 m[obj.id].li_attr[k] = t[type].li_attr[k];
|
|
|
8258 if (d) {
|
|
|
8259 if (k === 'class') {
|
|
|
8260 d.addClass(t[type].li_attr[k]);
|
|
|
8261 }
|
|
|
8262 else {
|
|
|
8263 d.attr(k, t[type].li_attr[k]);
|
|
|
8264 }
|
|
|
8265 }
|
|
|
8266 }
|
|
|
8267 else if (k === 'class') {
|
|
|
8268 m[obj.id].li_attr['class'] = t[type].li_attr[k] + ' ' + m[obj.id].li_attr['class'];
|
|
|
8269 if (d) { d.addClass(t[type].li_attr[k]); }
|
|
|
8270 }
|
|
|
8271 }
|
|
|
8272 }
|
|
|
8273 }
|
|
|
8274 if(t[type].a_attr !== undefined && typeof t[type].a_attr === 'object') {
|
|
|
8275 for (k in t[type].a_attr) {
|
|
|
8276 if (t[type].a_attr.hasOwnProperty(k)) {
|
|
|
8277 if (k === 'id') {
|
|
|
8278 continue;
|
|
|
8279 }
|
|
|
8280 else if (m[obj.id].a_attr[k] === undefined) {
|
|
|
8281 m[obj.id].a_attr[k] = t[type].a_attr[k];
|
|
|
8282 if (a) {
|
|
|
8283 if (k === 'class') {
|
|
|
8284 a.addClass(t[type].a_attr[k]);
|
|
|
8285 }
|
|
|
8286 else {
|
|
|
8287 a.attr(k, t[type].a_attr[k]);
|
|
|
8288 }
|
|
|
8289 }
|
|
|
8290 }
|
|
|
8291 else if (k === 'href' && m[obj.id].a_attr[k] === '#') {
|
|
|
8292 m[obj.id].a_attr['href'] = t[type].a_attr['href'];
|
|
|
8293 if (a) { a.attr('href', t[type].a_attr['href']); }
|
|
|
8294 }
|
|
|
8295 else if (k === 'class') {
|
|
|
8296 m[obj.id].a_attr['class'] = t[type].a_attr['class'] + ' ' + m[obj.id].a_attr['class'];
|
|
|
8297 if (a) { a.addClass(t[type].a_attr[k]); }
|
|
|
8298 }
|
|
|
8299 }
|
|
|
8300 }
|
|
|
8301 }
|
|
|
8302
|
|
|
8303 return true;
|
|
|
8304 };
|
|
|
8305 };
|
|
|
8306 // include the types plugin by default
|
|
|
8307 // $.jstree.defaults.plugins.push("types");
|
|
|
8308
|
|
|
8309
|
|
|
8310 /**
|
|
|
8311 * ### Unique plugin
|
|
|
8312 *
|
|
|
8313 * Enforces that no nodes with the same name can coexist as siblings.
|
|
|
8314 */
|
|
|
8315
|
|
|
8316 /**
|
|
|
8317 * stores all defaults for the unique plugin
|
|
|
8318 * @name $.jstree.defaults.unique
|
|
|
8319 * @plugin unique
|
|
|
8320 */
|
|
|
8321 $.jstree.defaults.unique = {
|
|
|
8322 /**
|
|
|
8323 * Indicates if the comparison should be case sensitive. Default is `false`.
|
|
|
8324 * @name $.jstree.defaults.unique.case_sensitive
|
|
|
8325 * @plugin unique
|
|
|
8326 */
|
|
|
8327 case_sensitive : false,
|
|
|
8328 /**
|
|
|
8329 * Indicates if white space should be trimmed before the comparison. Default is `false`.
|
|
|
8330 * @name $.jstree.defaults.unique.trim_whitespace
|
|
|
8331 * @plugin unique
|
|
|
8332 */
|
|
|
8333 trim_whitespace : false,
|
|
|
8334 /**
|
|
|
8335 * A callback executed in the instance's scope when a new node is created and the name is already taken, the two arguments are the conflicting name and the counter. The default will produce results like `New node (2)`.
|
|
|
8336 * @name $.jstree.defaults.unique.duplicate
|
|
|
8337 * @plugin unique
|
|
|
8338 */
|
|
|
8339 duplicate : function (name, counter) {
|
|
|
8340 return name + ' (' + counter + ')';
|
|
|
8341 }
|
|
|
8342 };
|
|
|
8343
|
|
|
8344 $.jstree.plugins.unique = function (options, parent) {
|
|
|
8345 this.check = function (chk, obj, par, pos, more) {
|
|
|
8346 if(parent.check.call(this, chk, obj, par, pos, more) === false) { return false; }
|
|
|
8347 obj = obj && obj.id ? obj : this.get_node(obj);
|
|
|
8348 par = par && par.id ? par : this.get_node(par);
|
|
|
8349 if(!par || !par.children) { return true; }
|
|
|
8350 var n = chk === "rename_node" ? pos : obj.text,
|
|
|
8351 c = [],
|
|
|
8352 s = this.settings.unique.case_sensitive,
|
|
|
8353 w = this.settings.unique.trim_whitespace,
|
|
|
8354 m = this._model.data, i, j, t;
|
|
|
8355 for(i = 0, j = par.children.length; i < j; i++) {
|
|
|
8356 t = m[par.children[i]].text;
|
|
|
8357 if (!s) {
|
|
|
8358 t = t.toLowerCase();
|
|
|
8359 }
|
|
|
8360 if (w) {
|
|
|
8361 t = t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
|
|
8362 }
|
|
|
8363 c.push(t);
|
|
|
8364 }
|
|
|
8365 if(!s) { n = n.toLowerCase(); }
|
|
|
8366 if (w) { n = n.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); }
|
|
|
8367 switch(chk) {
|
|
|
8368 case "delete_node":
|
|
|
8369 return true;
|
|
|
8370 case "rename_node":
|
|
|
8371 t = obj.text || '';
|
|
|
8372 if (!s) {
|
|
|
8373 t = t.toLowerCase();
|
|
|
8374 }
|
|
|
8375 if (w) {
|
|
|
8376 t = t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
|
|
8377 }
|
|
|
8378 i = ($.inArray(n, c) === -1 || (obj.text && t === n));
|
|
|
8379 if(!i) {
|
|
|
8380 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_01', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8381 }
|
|
|
8382 return i;
|
|
|
8383 case "create_node":
|
|
|
8384 i = ($.inArray(n, c) === -1);
|
|
|
8385 if(!i) {
|
|
|
8386 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_04', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8387 }
|
|
|
8388 return i;
|
|
|
8389 case "copy_node":
|
|
|
8390 i = ($.inArray(n, c) === -1);
|
|
|
8391 if(!i) {
|
|
|
8392 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_02', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8393 }
|
|
|
8394 return i;
|
|
|
8395 case "move_node":
|
|
|
8396 i = ( (obj.parent === par.id && (!more || !more.is_multi)) || $.inArray(n, c) === -1);
|
|
|
8397 if(!i) {
|
|
|
8398 this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_03', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };
|
|
|
8399 }
|
|
|
8400 return i;
|
|
|
8401 }
|
|
|
8402 return true;
|
|
|
8403 };
|
|
|
8404 this.create_node = function (par, node, pos, callback, is_loaded) {
|
|
|
8405 if(!node || node.text === undefined) {
|
|
|
8406 if(par === null) {
|
|
|
8407 par = $.jstree.root;
|
|
|
8408 }
|
|
|
8409 par = this.get_node(par);
|
|
|
8410 if(!par) {
|
|
|
8411 return parent.create_node.call(this, par, node, pos, callback, is_loaded);
|
|
|
8412 }
|
|
|
8413 pos = pos === undefined ? "last" : pos;
|
|
|
8414 if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {
|
|
|
8415 return parent.create_node.call(this, par, node, pos, callback, is_loaded);
|
|
|
8416 }
|
|
|
8417 if(!node) { node = {}; }
|
|
|
8418 var tmp, n, dpc, i, j, m = this._model.data, s = this.settings.unique.case_sensitive, w = this.settings.unique.trim_whitespace, cb = this.settings.unique.duplicate, t;
|
|
|
8419 n = tmp = this.get_string('New node');
|
|
|
8420 dpc = [];
|
|
|
8421 for(i = 0, j = par.children.length; i < j; i++) {
|
|
|
8422 t = m[par.children[i]].text;
|
|
|
8423 if (!s) {
|
|
|
8424 t = t.toLowerCase();
|
|
|
8425 }
|
|
|
8426 if (w) {
|
|
|
8427 t = t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
|
|
8428 }
|
|
|
8429 dpc.push(t);
|
|
|
8430 }
|
|
|
8431 i = 1;
|
|
|
8432 t = n;
|
|
|
8433 if (!s) {
|
|
|
8434 t = t.toLowerCase();
|
|
|
8435 }
|
|
|
8436 if (w) {
|
|
|
8437 t = t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
|
|
8438 }
|
|
|
8439 while($.inArray(t, dpc) !== -1) {
|
|
|
8440 n = cb.call(this, tmp, (++i)).toString();
|
|
|
8441 t = n;
|
|
|
8442 if (!s) {
|
|
|
8443 t = t.toLowerCase();
|
|
|
8444 }
|
|
|
8445 if (w) {
|
|
|
8446 t = t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
|
|
8447 }
|
|
|
8448 }
|
|
|
8449 node.text = n;
|
|
|
8450 }
|
|
|
8451 return parent.create_node.call(this, par, node, pos, callback, is_loaded);
|
|
|
8452 };
|
|
|
8453 };
|
|
|
8454
|
|
|
8455 // include the unique plugin by default
|
|
|
8456 // $.jstree.defaults.plugins.push("unique");
|
|
|
8457
|
|
|
8458
|
|
|
8459 /**
|
|
|
8460 * ### Wholerow plugin
|
|
|
8461 *
|
|
|
8462 * Makes each node appear block level. Making selection easier. May cause slow down for large trees in old browsers.
|
|
|
8463 */
|
|
|
8464
|
|
|
8465 var div = document.createElement('DIV');
|
|
|
8466 div.setAttribute('unselectable','on');
|
|
|
8467 div.setAttribute('role','presentation');
|
|
|
8468 div.className = 'jstree-wholerow';
|
|
|
8469 div.innerHTML = ' ';
|
|
|
8470 $.jstree.plugins.wholerow = function (options, parent) {
|
|
|
8471 this.bind = function () {
|
|
|
8472 parent.bind.call(this);
|
|
|
8473
|
|
|
8474 this.element
|
|
|
8475 .on('ready.jstree set_state.jstree', $.proxy(function () {
|
|
|
8476 this.hide_dots();
|
|
|
8477 }, this))
|
|
|
8478 .on("init.jstree loading.jstree ready.jstree", $.proxy(function () {
|
|
|
8479 //div.style.height = this._data.core.li_height + 'px';
|
|
|
8480 this.get_container_ul().addClass('jstree-wholerow-ul');
|
|
|
8481 }, this))
|
|
|
8482 .on("deselect_all.jstree", $.proxy(function (e, data) {
|
|
|
8483 this.element.find('.jstree-wholerow-clicked').removeClass('jstree-wholerow-clicked');
|
|
|
8484 }, this))
|
|
|
8485 .on("changed.jstree", $.proxy(function (e, data) {
|
|
|
8486 this.element.find('.jstree-wholerow-clicked').removeClass('jstree-wholerow-clicked');
|
|
|
8487 var tmp = false, i, j;
|
|
|
8488 for(i = 0, j = data.selected.length; i < j; i++) {
|
|
|
8489 tmp = this.get_node(data.selected[i], true);
|
|
|
8490 if(tmp && tmp.length) {
|
|
|
8491 tmp.children('.jstree-wholerow').addClass('jstree-wholerow-clicked');
|
|
|
8492 }
|
|
|
8493 }
|
|
|
8494 }, this))
|
|
|
8495 .on("open_node.jstree", $.proxy(function (e, data) {
|
|
|
8496 this.get_node(data.node, true).find('.jstree-clicked').parent().children('.jstree-wholerow').addClass('jstree-wholerow-clicked');
|
|
|
8497 }, this))
|
|
|
8498 .on("hover_node.jstree dehover_node.jstree", $.proxy(function (e, data) {
|
|
|
8499 if(e.type === "hover_node" && this.is_disabled(data.node)) { return; }
|
|
|
8500 this.get_node(data.node, true).children('.jstree-wholerow')[e.type === "hover_node"?"addClass":"removeClass"]('jstree-wholerow-hovered');
|
|
|
8501 }, this))
|
|
|
8502 .on("contextmenu.jstree", ".jstree-wholerow", $.proxy(function (e) {
|
|
|
8503 if (this._data.contextmenu) {
|
|
|
8504 e.preventDefault();
|
|
|
8505 var tmp = $.Event('contextmenu', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey, pageX : e.pageX, pageY : e.pageY });
|
|
|
8506 $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp);
|
|
|
8507 }
|
|
|
8508 }, this))
|
|
|
8509 /*!
|
|
|
8510 .on("mousedown.jstree touchstart.jstree", ".jstree-wholerow", function (e) {
|
|
|
8511 if(e.target === e.currentTarget) {
|
|
|
8512 var a = $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor");
|
|
|
8513 e.target = a[0];
|
|
|
8514 a.trigger(e);
|
|
|
8515 }
|
|
|
8516 })
|
|
|
8517 */
|
|
|
8518 .on("click.jstree", ".jstree-wholerow", function (e) {
|
|
|
8519 e.stopImmediatePropagation();
|
|
|
8520 var tmp = $.Event('click', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey });
|
|
|
8521 $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp).focus();
|
|
|
8522 })
|
|
|
8523 .on("dblclick.jstree", ".jstree-wholerow", function (e) {
|
|
|
8524 e.stopImmediatePropagation();
|
|
|
8525 var tmp = $.Event('dblclick', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey });
|
|
|
8526 $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp).focus();
|
|
|
8527 })
|
|
|
8528 .on("click.jstree", ".jstree-leaf > .jstree-ocl", $.proxy(function (e) {
|
|
|
8529 e.stopImmediatePropagation();
|
|
|
8530 var tmp = $.Event('click', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey });
|
|
|
8531 $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp).focus();
|
|
|
8532 }, this))
|
|
|
8533 .on("mouseover.jstree", ".jstree-wholerow, .jstree-icon", $.proxy(function (e) {
|
|
|
8534 e.stopImmediatePropagation();
|
|
|
8535 if(!this.is_disabled(e.currentTarget)) {
|
|
|
8536 this.hover_node(e.currentTarget);
|
|
|
8537 }
|
|
|
8538 return false;
|
|
|
8539 }, this))
|
|
|
8540 .on("mouseleave.jstree", ".jstree-node", $.proxy(function (e) {
|
|
|
8541 this.dehover_node(e.currentTarget);
|
|
|
8542 }, this));
|
|
|
8543 };
|
|
|
8544 this.teardown = function () {
|
|
|
8545 if(this.settings.wholerow) {
|
|
|
8546 this.element.find(".jstree-wholerow").remove();
|
|
|
8547 }
|
|
|
8548 parent.teardown.call(this);
|
|
|
8549 };
|
|
|
8550 this.redraw_node = function(obj, deep, callback, force_render) {
|
|
|
8551 obj = parent.redraw_node.apply(this, arguments);
|
|
|
8552 if(obj) {
|
|
|
8553 var tmp = div.cloneNode(true);
|
|
|
8554 //tmp.style.height = this._data.core.li_height + 'px';
|
|
|
8555 if($.inArray(obj.id, this._data.core.selected) !== -1) { tmp.className += ' jstree-wholerow-clicked'; }
|
|
|
8556 if(this._data.core.focused && this._data.core.focused === obj.id) { tmp.className += ' jstree-wholerow-hovered'; }
|
|
|
8557 obj.insertBefore(tmp, obj.childNodes[0]);
|
|
|
8558 }
|
|
|
8559 return obj;
|
|
|
8560 };
|
|
|
8561 };
|
|
|
8562 // include the wholerow plugin by default
|
|
|
8563 // $.jstree.defaults.plugins.push("wholerow");
|
|
|
8564 if(document.registerElement && Object && Object.create) {
|
|
|
8565 var proto = Object.create(HTMLElement.prototype);
|
|
|
8566 proto.createdCallback = function () {
|
|
|
8567 var c = { core : {}, plugins : [] }, i;
|
|
|
8568 for(i in $.jstree.plugins) {
|
|
|
8569 if($.jstree.plugins.hasOwnProperty(i) && this.attributes[i]) {
|
|
|
8570 c.plugins.push(i);
|
|
|
8571 if(this.getAttribute(i) && JSON.parse(this.getAttribute(i))) {
|
|
|
8572 c[i] = JSON.parse(this.getAttribute(i));
|
|
|
8573 }
|
|
|
8574 }
|
|
|
8575 }
|
|
|
8576 for(i in $.jstree.defaults.core) {
|
|
|
8577 if($.jstree.defaults.core.hasOwnProperty(i) && this.attributes[i]) {
|
|
|
8578 c.core[i] = JSON.parse(this.getAttribute(i)) || this.getAttribute(i);
|
|
|
8579 }
|
|
|
8580 }
|
|
|
8581 $(this).jstree(c);
|
|
|
8582 };
|
|
|
8583 // proto.attributeChangedCallback = function (name, previous, value) { };
|
|
|
8584 try {
|
|
|
8585 document.registerElement("vakata-jstree", { prototype: proto });
|
|
|
8586 } catch(ignore) { }
|
|
|
8587 }
|
|
|
8588
|
|
|
8589 })); |
