",{id:"ft-id-"+this._id,class:"ui-fancytree fancytree-container fancytree-plain"}).appendTo(this.$div),this.$container=t,this.rootNode.ul=t[0],null==this.options.debugLevel&&(this.options.debugLevel=g.debugLevel)}k.ui.fancytree.warn("Fancytree: ignored duplicate include")});
\ No newline at end of file
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.ariagrid.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.ariagrid.js
new file mode 100644
index 0000000..7a62e2e
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.ariagrid.js
@@ -0,0 +1,718 @@
+/*!
+ * jquery.fancytree.ariagrid.js
+ *
+ * Support ARIA compliant markup and keyboard navigation for tree grids with
+ * embedded input controls.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * @requires ext-table
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define([
+ "jquery",
+ "./jquery.fancytree",
+ "./jquery.fancytree.table",
+ ], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree.table"); // core + table
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /*******************************************************************************
+ * Private functions and variables
+ */
+
+ // Allow these navigation keys even when input controls are focused
+
+ var FT = $.ui.fancytree,
+ clsFancytreeActiveCell = "fancytree-active-cell",
+ clsFancytreeCellMode = "fancytree-cell-mode",
+ clsFancytreeCellNavMode = "fancytree-cell-nav-mode",
+ VALID_MODES = ["allow", "force", "start", "off"],
+ // Define which keys are handled by embedded , or `$(td)`
+ if (typeof callOpts.cell === "number") {
+ $td = findTdAtColIdx($tr, callOpts.cell);
+ } else {
+ $td = $(callOpts.cell);
+ }
+ tree.activateCell($td);
+ return;
+ }
+ // tree.debug( "nodeSetActive: activeNode " + this.activeNode );
+ return this._superApply(arguments);
+ },
+ nodeKeydown: function(ctx) {
+ var handleKeys,
+ inputType,
+ res,
+ $td,
+ $embeddedCheckbox = null,
+ tree = ctx.tree,
+ node = ctx.node,
+ treeOpts = ctx.options,
+ opts = treeOpts.ariagrid,
+ event = ctx.originalEvent,
+ eventString = FT.eventToString(event),
+ $target = $(event.target),
+ $activeTd = this.$activeTd,
+ $activeTr = $activeTd ? $activeTd.closest("tr") : null,
+ colIdx = $activeTd ? getColIdx($activeTr, $activeTd) : -1,
+ forceNav =
+ $activeTd &&
+ tree.forceNavMode &&
+ $.inArray(eventString, NAV_KEYS) >= 0;
+
+ if (opts.cellFocus === "off") {
+ return this._superApply(arguments);
+ }
+
+ if ($target.is(":input:enabled")) {
+ inputType = $target.prop("type");
+ } else if ($target.is("a")) {
+ inputType = "link";
+ }
+ if ($activeTd && $activeTd.find(":checkbox:enabled").length === 1) {
+ $embeddedCheckbox = $activeTd.find(":checkbox:enabled");
+ inputType = "checkbox";
+ }
+ tree.debug(
+ "nodeKeydown(" +
+ eventString +
+ "), activeTd: '" +
+ ($activeTd && $activeTd.text()) +
+ "', inputType: " +
+ inputType
+ );
+
+ if (inputType && eventString !== "esc" && !forceNav) {
+ handleKeys = INPUT_KEYS[inputType];
+ if (handleKeys && $.inArray(eventString, handleKeys) >= 0) {
+ return; // Let input control handle the key
+ }
+ }
+
+ switch (eventString) {
+ case "right":
+ if ($activeTd) {
+ // Cell mode: move to neighbour (stop on right border)
+ $td = findNeighbourTd(tree, $activeTd, eventString);
+ if ($td) {
+ tree.activateCell($td);
+ }
+ } else if (
+ node &&
+ !node.isExpanded() &&
+ node.hasChildren() !== false
+ ) {
+ // Row mode and current node can be expanded:
+ // default handling will expand.
+ break;
+ } else {
+ // Row mode: switch to cell-mode
+ $td = $(node.tr)
+ .find(">td")
+ .first();
+ tree.activateCell($td);
+ }
+ return false; // no default handling
+
+ case "left":
+ case "home":
+ case "end":
+ case "ctrl+home":
+ case "ctrl+end":
+ case "up":
+ case "down":
+ if ($activeTd) {
+ // Cell mode: move to neighbour
+ $td = findNeighbourTd(tree, $activeTd, eventString);
+ // Note: $td may be null if we move outside bounds. In this case
+ // we switch back to row-mode (i.e. call activateCell(null) ).
+ if (!$td && "left right".indexOf(eventString) < 0) {
+ // Only switch to row-mode if left/right hits the bounds
+ return false;
+ }
+ if ($td || opts.cellFocus !== "force") {
+ tree.activateCell($td);
+ }
+ return false;
+ }
+ break;
+
+ case "esc":
+ if ($activeTd && !tree.forceNavMode) {
+ // Switch from cell-edit-mode to cell-nav-mode
+ // $target.closest( "td" ).focus();
+ tree.forceNavMode = true;
+ tree.debug("Enter cell-nav-mode");
+ tree.$container.toggleClass(
+ clsFancytreeCellNavMode,
+ !!tree.forceNavMode
+ );
+ return false;
+ } else if ($activeTd && opts.cellFocus !== "force") {
+ // Switch back from cell-mode to row-mode
+ tree.activateCell(null);
+ return false;
+ }
+ // tree.$container.toggleClass( clsFancytreeCellNavMode, !!tree.forceNavMode );
+ break;
+
+ case "return":
+ // Let user override the default action.
+ // This event is triggered in row-mode and cell-mode
+ res = tree._triggerNodeEvent(
+ "defaultGridAction",
+ node,
+ event,
+ {
+ activeTd: tree.$activeTd ? tree.$activeTd[0] : null,
+ colIdx: colIdx,
+ mode: getGridNavMode(tree),
+ }
+ );
+ if (res === false) {
+ return false;
+ }
+ // Implement default actions (for cell-mode only).
+ if ($activeTd) {
+ // Apply 'default action' for embedded cell control
+ if (colIdx === this.nodeColumnIdx) {
+ node.toggleExpanded();
+ } else if (colIdx === this.checkboxColumnIdx) {
+ // TODO: only in checkbox mode!
+ node.toggleSelected();
+ } else if ($embeddedCheckbox) {
+ // Embedded checkboxes are always toggled (ignoring `autoFocusInput`)
+ $embeddedCheckbox.prop(
+ "checked",
+ !$embeddedCheckbox.prop("checked")
+ );
+ } else if (tree.forceNavMode && $target.is(":input")) {
+ tree.forceNavMode = false;
+ tree.$container.removeClass(
+ clsFancytreeCellNavMode
+ );
+ tree.debug("enable cell-edit-mode");
+ } else if ($activeTd.find("a").length === 1) {
+ activateEmbeddedLink($activeTd);
+ }
+ } else {
+ // ENTER in row-mode: Switch from row-mode to cell-mode
+ // TODO: it was also suggested to expand/collapse instead
+ // https://github.com/w3c/aria-practices/issues/132#issuecomment-407634891
+ $td = $(node.tr)
+ .find(">td")
+ .nth(this.nodeColumnIdx);
+ tree.activateCell($td);
+ }
+ return false; // no default handling
+
+ case "space":
+ if ($activeTd) {
+ if (colIdx === this.checkboxColumnIdx) {
+ node.toggleSelected();
+ } else if ($embeddedCheckbox) {
+ $embeddedCheckbox.prop(
+ "checked",
+ !$embeddedCheckbox.prop("checked")
+ );
+ }
+ return false; // no default handling
+ }
+ break;
+
+ default:
+ // Allow to focus input by typing alphanum keys
+ }
+ return this._superApply(arguments);
+ },
+ treeSetOption: function(ctx, key, value) {
+ var tree = ctx.tree,
+ opts = tree.options.ariagrid;
+
+ if (key === "ariagrid") {
+ // User called `$().fancytree("option", "ariagrid.SUBKEY", VALUE)`
+ if (value.cellFocus !== opts.cellFocus) {
+ if ($.inArray(value.cellFocus, VALID_MODES) < 0) {
+ $.error("Invalid `cellFocus` option");
+ }
+ // TODO: fix current focus and mode
+ }
+ }
+ return this._superApply(arguments);
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.childcounter.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.childcounter.js
new file mode 100644
index 0000000..d15f18b
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.childcounter.js
@@ -0,0 +1,239 @@
+// Extending Fancytree
+// ===================
+//
+// See also the [live demo](https://wwWendt.de/tech/fancytree/demo/sample-ext-childcounter.html) of this code.
+//
+// Every extension should have a comment header containing some information
+// about the author, copyright and licensing. Also a pointer to the latest
+// source code.
+// Prefix with `/*!` so the comment is not removed by the minifier.
+
+/*!
+ * jquery.fancytree.childcounter.js
+ *
+ * Add a child counter bubble to tree nodes.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+// To keep the global namespace clean, we wrap everything in a closure.
+// The UMD wrapper pattern defines the dependencies on jQuery and the
+// Fancytree core module, and makes sure that we can use the `require()`
+// syntax with package loaders.
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ // Consider to use [strict mode](http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/)
+ "use strict";
+
+ // The [coding guidelines](http://contribute.jquery.org/style-guide/js/)
+ // require jshint /eslint compliance.
+ // But for this sample, we want to allow unused variables for demonstration purpose.
+
+ /*eslint-disable no-unused-vars */
+
+ // Adding methods
+ // --------------
+
+ // New member functions can be added to the `Fancytree` class.
+ // This function will be available for every tree instance:
+ //
+ // var tree = $.ui.fancytree.getTree("#tree");
+ // tree.countSelected(false);
+
+ $.ui.fancytree._FancytreeClass.prototype.countSelected = function(topOnly) {
+ var tree = this,
+ treeOptions = tree.options;
+
+ return tree.getSelectedNodes(topOnly).length;
+ };
+
+ // The `FancytreeNode` class can also be easily extended. This would be called
+ // like
+ // node.updateCounters();
+ //
+ // It is also good practice to add a docstring comment.
+ /**
+ * [ext-childcounter] Update counter badges for `node` and its parents.
+ * May be called in the `loadChildren` event, to update parents of lazy loaded
+ * nodes.
+ * @alias FancytreeNode#updateCounters
+ * @requires jquery.fancytree.childcounters.js
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.updateCounters = function() {
+ var node = this,
+ $badge = $("span.fancytree-childcounter", node.span),
+ extOpts = node.tree.options.childcounter,
+ count = node.countChildren(extOpts.deep);
+
+ node.data.childCounter = count;
+ if (
+ (count || !extOpts.hideZeros) &&
+ (!node.isExpanded() || !extOpts.hideExpanded)
+ ) {
+ if (!$badge.length) {
+ $badge = $("Gary Court
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author Austin Appleby
+ * @see http://sites.google.com/site/murmurhash/
+ *
+ * @param {string} key ASCII only
+ * @param {boolean} [asString=false]
+ * @param {number} seed Positive integer only
+ * @return {number} 32-bit positive integer hash
+ */
+ function hashMurmur3(key, asString, seed) {
+ /*eslint-disable no-bitwise */
+ var h1b,
+ k1,
+ remainder = key.length & 3,
+ bytes = key.length - remainder,
+ h1 = seed,
+ c1 = 0xcc9e2d51,
+ c2 = 0x1b873593,
+ i = 0;
+
+ while (i < bytes) {
+ k1 =
+ (key.charCodeAt(i) & 0xff) |
+ ((key.charCodeAt(++i) & 0xff) << 8) |
+ ((key.charCodeAt(++i) & 0xff) << 16) |
+ ((key.charCodeAt(++i) & 0xff) << 24);
+ ++i;
+
+ k1 =
+ ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) &
+ 0xffffffff;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 =
+ ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) &
+ 0xffffffff;
+
+ h1 ^= k1;
+ h1 = (h1 << 13) | (h1 >>> 19);
+ h1b =
+ ((h1 & 0xffff) * 5 + ((((h1 >>> 16) * 5) & 0xffff) << 16)) &
+ 0xffffffff;
+ h1 =
+ (h1b & 0xffff) +
+ 0x6b64 +
+ ((((h1b >>> 16) + 0xe654) & 0xffff) << 16);
+ }
+
+ k1 = 0;
+
+ switch (remainder) {
+ case 3:
+ k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+ // fall through
+ case 2:
+ k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+ // fall through
+ case 1:
+ k1 ^= key.charCodeAt(i) & 0xff;
+
+ k1 =
+ ((k1 & 0xffff) * c1 +
+ ((((k1 >>> 16) * c1) & 0xffff) << 16)) &
+ 0xffffffff;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 =
+ ((k1 & 0xffff) * c2 +
+ ((((k1 >>> 16) * c2) & 0xffff) << 16)) &
+ 0xffffffff;
+ h1 ^= k1;
+ }
+
+ h1 ^= key.length;
+
+ h1 ^= h1 >>> 16;
+ h1 =
+ ((h1 & 0xffff) * 0x85ebca6b +
+ ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) &
+ 0xffffffff;
+ h1 ^= h1 >>> 13;
+ h1 =
+ ((h1 & 0xffff) * 0xc2b2ae35 +
+ ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)) &
+ 0xffffffff;
+ h1 ^= h1 >>> 16;
+
+ if (asString) {
+ // Convert to 8 digit hex string
+ return ("0000000" + (h1 >>> 0).toString(16)).substr(-8);
+ }
+ return h1 >>> 0;
+ /*eslint-enable no-bitwise */
+ }
+
+ /*
+ * Return a unique key for node by calculating the hash of the parents refKey-list.
+ */
+ function calcUniqueKey(node) {
+ var key,
+ h1,
+ path = $.map(node.getParentList(false, true), function(e) {
+ return e.refKey || e.key;
+ });
+
+ path = path.join("/");
+ // 32-bit has a high probability of collisions, so we pump up to 64-bit
+ // https://security.stackexchange.com/q/209882/207588
+
+ h1 = hashMurmur3(path, true);
+ key = "id_" + h1 + hashMurmur3(h1 + path, true);
+
+ return key;
+ }
+
+ /**
+ * [ext-clones] Return a list of clone-nodes (i.e. same refKey) or null.
+ * @param {boolean} [includeSelf=false]
+ * @returns {FancytreeNode[] | null}
+ *
+ * @alias FancytreeNode#getCloneList
+ * @requires jquery.fancytree.clones.js
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.getCloneList = function(
+ includeSelf
+ ) {
+ var key,
+ tree = this.tree,
+ refList = tree.refMap[this.refKey] || null,
+ keyMap = tree.keyMap;
+
+ if (refList) {
+ key = this.key;
+ // Convert key list to node list
+ if (includeSelf) {
+ refList = $.map(refList, function(val) {
+ return keyMap[val];
+ });
+ } else {
+ refList = $.map(refList, function(val) {
+ return val === key ? null : keyMap[val];
+ });
+ if (refList.length < 1) {
+ refList = null;
+ }
+ }
+ }
+ return refList;
+ };
+
+ /**
+ * [ext-clones] Return true if this node has at least another clone with same refKey.
+ * @returns {boolean}
+ *
+ * @alias FancytreeNode#isClone
+ * @requires jquery.fancytree.clones.js
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.isClone = function() {
+ var refKey = this.refKey || null,
+ refList = (refKey && this.tree.refMap[refKey]) || null;
+ return !!(refList && refList.length > 1);
+ };
+
+ /**
+ * [ext-clones] Update key and/or refKey for an existing node.
+ * @param {string} key
+ * @param {string} refKey
+ * @returns {boolean}
+ *
+ * @alias FancytreeNode#reRegister
+ * @requires jquery.fancytree.clones.js
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.reRegister = function(
+ key,
+ refKey
+ ) {
+ key = key == null ? null : "" + key;
+ refKey = refKey == null ? null : "" + refKey;
+ // this.debug("reRegister", key, refKey);
+
+ var tree = this.tree,
+ prevKey = this.key,
+ prevRefKey = this.refKey,
+ keyMap = tree.keyMap,
+ refMap = tree.refMap,
+ refList = refMap[prevRefKey] || null,
+ // curCloneKeys = refList ? node.getCloneList(true),
+ modified = false;
+
+ // Key has changed: update all references
+ if (key != null && key !== this.key) {
+ if (keyMap[key]) {
+ $.error(
+ "[ext-clones] reRegister(" +
+ key +
+ "): already exists: " +
+ this
+ );
+ }
+ // Update keyMap
+ delete keyMap[prevKey];
+ keyMap[key] = this;
+ // Update refMap
+ if (refList) {
+ refMap[prevRefKey] = $.map(refList, function(e) {
+ return e === prevKey ? key : e;
+ });
+ }
+ this.key = key;
+ modified = true;
+ }
+
+ // refKey has changed
+ if (refKey != null && refKey !== this.refKey) {
+ // Remove previous refKeys
+ if (refList) {
+ if (refList.length === 1) {
+ delete refMap[prevRefKey];
+ } else {
+ refMap[prevRefKey] = $.map(refList, function(e) {
+ return e === prevKey ? null : e;
+ });
+ }
+ }
+ // Add refKey
+ if (refMap[refKey]) {
+ refMap[refKey].append(key);
+ } else {
+ refMap[refKey] = [this.key];
+ }
+ this.refKey = refKey;
+ modified = true;
+ }
+ return modified;
+ };
+
+ /**
+ * [ext-clones] Define a refKey for an existing node.
+ * @param {string} refKey
+ * @returns {boolean}
+ *
+ * @alias FancytreeNode#setRefKey
+ * @requires jquery.fancytree.clones.js
+ * @since 2.16
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.setRefKey = function(refKey) {
+ return this.reRegister(null, refKey);
+ };
+
+ /**
+ * [ext-clones] Return all nodes with a given refKey (null if not found).
+ * @param {string} refKey
+ * @param {FancytreeNode} [rootNode] optionally restrict results to descendants of this node
+ * @returns {FancytreeNode[] | null}
+ * @alias Fancytree#getNodesByRef
+ * @requires jquery.fancytree.clones.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.getNodesByRef = function(
+ refKey,
+ rootNode
+ ) {
+ var keyMap = this.keyMap,
+ refList = this.refMap[refKey] || null;
+
+ if (refList) {
+ // Convert key list to node list
+ if (rootNode) {
+ refList = $.map(refList, function(val) {
+ var node = keyMap[val];
+ return node.isDescendantOf(rootNode) ? node : null;
+ });
+ } else {
+ refList = $.map(refList, function(val) {
+ return keyMap[val];
+ });
+ }
+ if (refList.length < 1) {
+ refList = null;
+ }
+ }
+ return refList;
+ };
+
+ /**
+ * [ext-clones] Replace a refKey with a new one.
+ * @param {string} oldRefKey
+ * @param {string} newRefKey
+ * @alias Fancytree#changeRefKey
+ * @requires jquery.fancytree.clones.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.changeRefKey = function(
+ oldRefKey,
+ newRefKey
+ ) {
+ var i,
+ node,
+ keyMap = this.keyMap,
+ refList = this.refMap[oldRefKey] || null;
+
+ if (refList) {
+ for (i = 0; i < refList.length; i++) {
+ node = keyMap[refList[i]];
+ node.refKey = newRefKey;
+ }
+ delete this.refMap[oldRefKey];
+ this.refMap[newRefKey] = refList;
+ }
+ };
+
+ /*******************************************************************************
+ * Extension code
+ */
+ $.ui.fancytree.registerExtension({
+ name: "clones",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {
+ highlightActiveClones: true, // set 'fancytree-active-clone' on active clones and all peers
+ highlightClones: false, // set 'fancytree-clone' class on any node that has at least one clone
+ },
+
+ treeCreate: function(ctx) {
+ this._superApply(arguments);
+ ctx.tree.refMap = {};
+ ctx.tree.keyMap = {};
+ },
+ treeInit: function(ctx) {
+ this.$container.addClass("fancytree-ext-clones");
+ _assert(ctx.options.defaultKey == null);
+ // Generate unique / reproducible default keys
+ ctx.options.defaultKey = function(node) {
+ return calcUniqueKey(node);
+ };
+ // The default implementation loads initial data
+ this._superApply(arguments);
+ },
+ treeClear: function(ctx) {
+ ctx.tree.refMap = {};
+ ctx.tree.keyMap = {};
+ return this._superApply(arguments);
+ },
+ treeRegisterNode: function(ctx, add, node) {
+ var refList,
+ len,
+ tree = ctx.tree,
+ keyMap = tree.keyMap,
+ refMap = tree.refMap,
+ key = node.key,
+ refKey = node && node.refKey != null ? "" + node.refKey : null;
+
+ // ctx.tree.debug("clones.treeRegisterNode", add, node);
+
+ if (node.isStatusNode()) {
+ return this._super(ctx, add, node);
+ }
+
+ if (add) {
+ if (keyMap[node.key] != null) {
+ var other = keyMap[node.key],
+ msg =
+ "clones.treeRegisterNode: duplicate key '" +
+ node.key +
+ "': /" +
+ node.getPath(true) +
+ " => " +
+ other.getPath(true);
+ // Sometimes this exception is not visible in the console,
+ // so we also write it:
+ tree.error(msg);
+ $.error(msg);
+ }
+ keyMap[key] = node;
+
+ if (refKey) {
+ refList = refMap[refKey];
+ if (refList) {
+ refList.push(key);
+ if (
+ refList.length === 2 &&
+ ctx.options.clones.highlightClones
+ ) {
+ // Mark peer node, if it just became a clone (no need to
+ // mark current node, since it will be rendered later anyway)
+ keyMap[refList[0]].renderStatus();
+ }
+ } else {
+ refMap[refKey] = [key];
+ }
+ // node.debug("clones.treeRegisterNode: add clone =>", refMap[refKey]);
+ }
+ } else {
+ if (keyMap[key] == null) {
+ $.error(
+ "clones.treeRegisterNode: node.key not registered: " +
+ node.key
+ );
+ }
+ delete keyMap[key];
+ if (refKey) {
+ refList = refMap[refKey];
+ // node.debug("clones.treeRegisterNode: remove clone BEFORE =>", refMap[refKey]);
+ if (refList) {
+ len = refList.length;
+ if (len <= 1) {
+ _assert(len === 1);
+ _assert(refList[0] === key);
+ delete refMap[refKey];
+ } else {
+ _removeArrayMember(refList, key);
+ // Unmark peer node, if this was the only clone
+ if (
+ len === 2 &&
+ ctx.options.clones.highlightClones
+ ) {
+ // node.debug("clones.treeRegisterNode: last =>", node.getCloneList());
+ keyMap[refList[0]].renderStatus();
+ }
+ }
+ // node.debug("clones.treeRegisterNode: remove clone =>", refMap[refKey]);
+ }
+ }
+ }
+ return this._super(ctx, add, node);
+ },
+ nodeRenderStatus: function(ctx) {
+ var $span,
+ res,
+ node = ctx.node;
+
+ res = this._super(ctx);
+
+ if (ctx.options.clones.highlightClones) {
+ $span = $(node[ctx.tree.statusClassPropName]);
+ // Only if span already exists
+ if ($span.length && node.isClone()) {
+ // node.debug("clones.nodeRenderStatus: ", ctx.options.clones.highlightClones);
+ $span.addClass("fancytree-clone");
+ }
+ }
+ return res;
+ },
+ nodeSetActive: function(ctx, flag, callOpts) {
+ var res,
+ scpn = ctx.tree.statusClassPropName,
+ node = ctx.node;
+
+ res = this._superApply(arguments);
+
+ if (ctx.options.clones.highlightActiveClones && node.isClone()) {
+ $.each(node.getCloneList(true), function(idx, n) {
+ // n.debug("clones.nodeSetActive: ", flag !== false);
+ $(n[scpn]).toggleClass(
+ "fancytree-active-clone",
+ flag !== false
+ );
+ });
+ }
+ return res;
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.columnview.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.columnview.js
new file mode 100644
index 0000000..7c81e38
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.columnview.js
@@ -0,0 +1,216 @@
+/*!
+ * jquery.fancytree.columnview.js
+ *
+ * Render tree like a Mac Finder's column view.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /*******************************************************************************
+ * Private functions and variables
+ */
+ var _assert = $.ui.fancytree.assert,
+ FT = $.ui.fancytree;
+
+ /*******************************************************************************
+ * Private functions and variables
+ */
+ $.ui.fancytree.registerExtension({
+ name: "columnview",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {},
+ // Overide virtual methods for this extension.
+ // `this` : is this extension object
+ // `this._base` : the Fancytree instance
+ // `this._super`: the virtual function that was overriden (member of prev. extension or Fancytree)
+ treeInit: function(ctx) {
+ var $tdFirst,
+ $ul,
+ tree = ctx.tree,
+ $table = tree.widget.element;
+
+ tree.tr = $("tbody tr", $table)[0];
+ tree.$tdList = $(">td", tree.tr);
+ tree.columnCount = tree.$tdList.length;
+ // Perform default behavior
+ this._superApply(arguments);
+ // Standard Fancytree created a root . Now move this into first table cell
+ $ul = $(tree.rootNode.ul);
+ $tdFirst = tree.$tdList.eq(0);
+
+ _assert(
+ $.inArray("table", this.options.extensions) < 0,
+ "columnview extensions must not use ext-table"
+ );
+ _assert(
+ tree.columnCount >= 2,
+ "columnview target must be a table with at least two columns"
+ );
+
+ $ul.removeClass("fancytree-container").removeAttr("tabindex");
+ tree.$container = $table;
+ $table
+ .addClass("fancytree-container fancytree-ext-columnview")
+ .attr("tabindex", "0");
+
+ $tdFirst.empty();
+ $ul.detach().appendTo($tdFirst);
+
+ // Force some required options
+ tree.widget.options.autoCollapse = true;
+ // tree.widget.options.autoActivate = true;
+ tree.widget.options.toggleEffect = false;
+ tree.widget.options.clickFolderMode = 1;
+
+ $table
+ // Make sure that only active path is expanded when a node is activated:
+ .on("fancytreeactivate", function(event, data) {
+ var node = data.node,
+ tree = data.tree,
+ level = node.getLevel();
+
+ tree._callHook("nodeCollapseSiblings", node);
+ // Clear right neighbours
+ if (!node.expanded) {
+ tree.$tdList
+ .eq(level)
+ .nextAll()
+ .empty();
+ }
+ // Expand nodes on activate, so we populate the right neighbor cell
+ if (!node.expanded && (node.children || node.lazy)) {
+ node.setExpanded();
+ }
+ })
+ // Adjust keyboard behaviour:
+ .on("fancytreekeydown", function(event, data) {
+ var next = null,
+ handled = true,
+ node = data.node || data.tree.getFirstChild();
+
+ if (node.getLevel() >= tree.columnCount) {
+ return;
+ }
+ switch (FT.eventToString(event)) {
+ case "down":
+ next = node.getNextSibling();
+ break;
+ case "left":
+ if (!node.isTopLevel()) {
+ next = node.getParent();
+ }
+ break;
+ case "right":
+ next = node.getFirstChild();
+ if (!next) {
+ // default processing: expand or ignore
+ return;
+ }
+ // Prefer an expanded child if any
+ next.visitSiblings(function(n) {
+ if (n.expanded) {
+ next = n;
+ return false;
+ }
+ }, true);
+ break;
+ case "up":
+ next = node.getPrevSibling();
+ break;
+ default:
+ handled = false;
+ }
+ if (next) {
+ next.setActive();
+ }
+ return !handled;
+ });
+ },
+ nodeSetExpanded: function(ctx, flag, callOpts) {
+ var $wait,
+ node = ctx.node,
+ tree = ctx.tree,
+ level = node.getLevel();
+
+ if (flag !== false && !node.expanded && node.isUndefined()) {
+ $wait = $(
+ ""
+ );
+ tree.$tdList
+ .eq(level)
+ .empty()
+ .append($wait);
+ }
+ return this._superApply(arguments);
+ },
+ nodeRemoveChildren: function(ctx) {
+ // #899: node's children removed: remove child marker...
+ $(ctx.node.span)
+ .find("span.fancytree-cv-right")
+ .remove();
+ // ...and clear right columns
+ ctx.tree.$tdList
+ .eq(ctx.node.getLevel())
+ .nextAll()
+ .empty();
+ return this._superApply(arguments);
+ },
+ nodeRender: function(ctx, force, deep, collapsed, _recursive) {
+ // Render standard nested - hierarchy
+ this._super(ctx, force, deep, collapsed, _recursive);
+ // Remove expander and add a trailing triangle instead
+ var level,
+ $tdChild,
+ $ul,
+ tree = ctx.tree,
+ node = ctx.node,
+ $span = $(node.span);
+
+ $span.find("span.fancytree-expander").remove();
+ if (
+ node.hasChildren() !== false &&
+ !$span.find("span.fancytree-cv-right").length
+ ) {
+ $span.append(
+ $("")
+ );
+ }
+ // Move with children into the appropriate
+ if (node.ul && node.expanded) {
+ node.ul.style.display = ""; // might be hidden if RIGHT was pressed
+ level = node.getLevel();
+ if (level < tree.columnCount) {
+ // only if we are not in the last column
+ $tdChild = tree.$tdList.eq(level);
+ $ul = $(node.ul).detach();
+ $tdChild.empty().append($ul);
+ }
+ }
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd.js
new file mode 100644
index 0000000..8bd1276
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd.js
@@ -0,0 +1,799 @@
+/*!
+ * jquery.fancytree.dnd.js
+ *
+ * Drag-and-drop support (jQuery UI draggable/droppable).
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define([
+ "jquery",
+ "jquery-ui/ui/widgets/draggable",
+ "jquery-ui/ui/widgets/droppable",
+ "./jquery.fancytree",
+ ], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /******************************************************************************
+ * Private functions and variables
+ */
+ var didRegisterDnd = false,
+ classDropAccept = "fancytree-drop-accept",
+ classDropAfter = "fancytree-drop-after",
+ classDropBefore = "fancytree-drop-before",
+ classDropOver = "fancytree-drop-over",
+ classDropReject = "fancytree-drop-reject",
+ classDropTarget = "fancytree-drop-target";
+
+ /* Convert number to string and prepend +/-; return empty string for 0.*/
+ function offsetString(n) {
+ // eslint-disable-next-line no-nested-ternary
+ return n === 0 ? "" : n > 0 ? "+" + n : "" + n;
+ }
+
+ //--- Extend ui.draggable event handling --------------------------------------
+
+ function _registerDnd() {
+ if (didRegisterDnd) {
+ return;
+ }
+
+ // Register proxy-functions for draggable.start/drag/stop
+
+ $.ui.plugin.add("draggable", "connectToFancytree", {
+ start: function(event, ui) {
+ // 'draggable' was renamed to 'ui-draggable' since jQueryUI 1.10
+ var draggable =
+ $(this).data("ui-draggable") ||
+ $(this).data("draggable"),
+ sourceNode = ui.helper.data("ftSourceNode") || null;
+
+ if (sourceNode) {
+ // Adjust helper offset, so cursor is slightly outside top/left corner
+ draggable.offset.click.top = -2;
+ draggable.offset.click.left = +16;
+ // Trigger dragStart event
+ // TODO: when called as connectTo..., the return value is ignored(?)
+ return sourceNode.tree.ext.dnd._onDragEvent(
+ "start",
+ sourceNode,
+ null,
+ event,
+ ui,
+ draggable
+ );
+ }
+ },
+ drag: function(event, ui) {
+ var ctx,
+ isHelper,
+ logObject,
+ // 'draggable' was renamed to 'ui-draggable' since jQueryUI 1.10
+ draggable =
+ $(this).data("ui-draggable") ||
+ $(this).data("draggable"),
+ sourceNode = ui.helper.data("ftSourceNode") || null,
+ prevTargetNode = ui.helper.data("ftTargetNode") || null,
+ targetNode = $.ui.fancytree.getNode(event.target),
+ dndOpts = sourceNode && sourceNode.tree.options.dnd;
+
+ // logObject = sourceNode || prevTargetNode || $.ui.fancytree;
+ // logObject.debug("Drag event:", event, event.shiftKey);
+ if (event.target && !targetNode) {
+ // We got a drag event, but the targetNode could not be found
+ // at the event location. This may happen,
+ // 1. if the mouse jumped over the drag helper,
+ // 2. or if a non-fancytree element is dragged
+ // We ignore it:
+ isHelper =
+ $(event.target).closest(
+ "div.fancytree-drag-helper,#fancytree-drop-marker"
+ ).length > 0;
+ if (isHelper) {
+ logObject =
+ sourceNode || prevTargetNode || $.ui.fancytree;
+ logObject.debug("Drag event over helper: ignored.");
+ return;
+ }
+ }
+ ui.helper.data("ftTargetNode", targetNode);
+
+ if (dndOpts && dndOpts.updateHelper) {
+ ctx = sourceNode.tree._makeHookContext(sourceNode, event, {
+ otherNode: targetNode,
+ ui: ui,
+ draggable: draggable,
+ dropMarker: $("#fancytree-drop-marker"),
+ });
+ dndOpts.updateHelper.call(sourceNode.tree, sourceNode, ctx);
+ }
+
+ // Leaving a tree node
+ if (prevTargetNode && prevTargetNode !== targetNode) {
+ prevTargetNode.tree.ext.dnd._onDragEvent(
+ "leave",
+ prevTargetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ }
+ if (targetNode) {
+ if (!targetNode.tree.options.dnd.dragDrop) {
+ // not enabled as drop target
+ } else if (targetNode === prevTargetNode) {
+ // Moving over same node
+ targetNode.tree.ext.dnd._onDragEvent(
+ "over",
+ targetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ } else {
+ // Entering this node first time
+ targetNode.tree.ext.dnd._onDragEvent(
+ "enter",
+ targetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ targetNode.tree.ext.dnd._onDragEvent(
+ "over",
+ targetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ }
+ }
+ // else go ahead with standard event handling
+ },
+ stop: function(event, ui) {
+ var logObject,
+ // 'draggable' was renamed to 'ui-draggable' since jQueryUI 1.10:
+ draggable =
+ $(this).data("ui-draggable") ||
+ $(this).data("draggable"),
+ sourceNode = ui.helper.data("ftSourceNode") || null,
+ targetNode = ui.helper.data("ftTargetNode") || null,
+ dropped = event.type === "mouseup" && event.which === 1;
+
+ if (!dropped) {
+ logObject = sourceNode || targetNode || $.ui.fancytree;
+ logObject.debug("Drag was cancelled");
+ }
+ if (targetNode) {
+ if (dropped) {
+ targetNode.tree.ext.dnd._onDragEvent(
+ "drop",
+ targetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ }
+ targetNode.tree.ext.dnd._onDragEvent(
+ "leave",
+ targetNode,
+ sourceNode,
+ event,
+ ui,
+ draggable
+ );
+ }
+ if (sourceNode) {
+ sourceNode.tree.ext.dnd._onDragEvent(
+ "stop",
+ sourceNode,
+ null,
+ event,
+ ui,
+ draggable
+ );
+ }
+ },
+ });
+
+ didRegisterDnd = true;
+ }
+
+ /******************************************************************************
+ * Drag and drop support
+ */
+ function _initDragAndDrop(tree) {
+ var dnd = tree.options.dnd || null,
+ glyph = tree.options.glyph || null;
+
+ // Register 'connectToFancytree' option with ui.draggable
+ if (dnd) {
+ _registerDnd();
+ }
+ // Attach ui.draggable to this Fancytree instance
+ if (dnd && dnd.dragStart) {
+ tree.widget.element.draggable(
+ $.extend(
+ {
+ addClasses: false,
+ // DT issue 244: helper should be child of scrollParent:
+ appendTo: tree.$container,
+ // appendTo: "body",
+ containment: false,
+ // containment: "parent",
+ delay: 0,
+ distance: 4,
+ revert: false,
+ scroll: true, // to disable, also set css 'position: inherit' on ul.fancytree-container
+ scrollSpeed: 7,
+ scrollSensitivity: 10,
+ // Delegate draggable.start, drag, and stop events to our handler
+ connectToFancytree: true,
+ // Let source tree create the helper element
+ helper: function(event) {
+ var $helper,
+ $nodeTag,
+ opts,
+ sourceNode = $.ui.fancytree.getNode(
+ event.target
+ );
+
+ if (!sourceNode) {
+ // #405, DT issue 211: might happen, if dragging a table *header*
+ return "ERROR?: helper requested but sourceNode not found
";
+ }
+ opts = sourceNode.tree.options.dnd;
+ $nodeTag = $(sourceNode.span);
+ // Only event and node argument is available
+ $helper = $(
+ "
"
+ )
+ .css({ zIndex: 3, position: "relative" }) // so it appears above ext-wide selection bar
+ .append(
+ $nodeTag
+ .find("span.fancytree-title")
+ .clone()
+ );
+
+ // Attach node reference to helper object
+ $helper.data("ftSourceNode", sourceNode);
+
+ // Support glyph symbols instead of icons
+ if (glyph) {
+ $helper
+ .find(".fancytree-drag-helper-img")
+ .addClass(
+ glyph.map._addClass +
+ " " +
+ glyph.map.dragHelper
+ );
+ }
+ // Allow to modify the helper, e.g. to add multi-node-drag feedback
+ if (opts.initHelper) {
+ opts.initHelper.call(
+ sourceNode.tree,
+ sourceNode,
+ {
+ node: sourceNode,
+ tree: sourceNode.tree,
+ originalEvent: event,
+ ui: { helper: $helper },
+ }
+ );
+ }
+ // We return an unconnected element, so `draggable` will add this
+ // to the parent specified as `appendTo` option
+ return $helper;
+ },
+ start: function(event, ui) {
+ var sourceNode = ui.helper.data("ftSourceNode");
+ return !!sourceNode; // Abort dragging if no node could be found
+ },
+ },
+ tree.options.dnd.draggable
+ )
+ );
+ }
+ // Attach ui.droppable to this Fancytree instance
+ if (dnd && dnd.dragDrop) {
+ tree.widget.element.droppable(
+ $.extend(
+ {
+ addClasses: false,
+ tolerance: "intersect",
+ greedy: false,
+ /*
+ activate: function(event, ui) {
+ tree.debug("droppable - activate", event, ui, this);
+ },
+ create: function(event, ui) {
+ tree.debug("droppable - create", event, ui);
+ },
+ deactivate: function(event, ui) {
+ tree.debug("droppable - deactivate", event, ui);
+ },
+ drop: function(event, ui) {
+ tree.debug("droppable - drop", event, ui);
+ },
+ out: function(event, ui) {
+ tree.debug("droppable - out", event, ui);
+ },
+ over: function(event, ui) {
+ tree.debug("droppable - over", event, ui);
+ }
+*/
+ },
+ tree.options.dnd.droppable
+ )
+ );
+ }
+ }
+
+ /******************************************************************************
+ *
+ */
+
+ $.ui.fancytree.registerExtension({
+ name: "dnd",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {
+ // Make tree nodes accept draggables
+ autoExpandMS: 1000, // Expand nodes after n milliseconds of hovering.
+ draggable: null, // Additional options passed to jQuery draggable
+ droppable: null, // Additional options passed to jQuery droppable
+ focusOnClick: false, // Focus, although draggable cancels mousedown event (#270)
+ preventVoidMoves: true, // Prevent dropping nodes 'before self', etc.
+ preventRecursiveMoves: true, // Prevent dropping nodes on own descendants
+ smartRevert: true, // set draggable.revert = true if drop was rejected
+ dropMarkerOffsetX: -24, // absolute position offset for .fancytree-drop-marker relatively to ..fancytree-title (icon/img near a node accepting drop)
+ dropMarkerInsertOffsetX: -16, // additional offset for drop-marker with hitMode = "before"/"after"
+ // Events (drag support)
+ dragStart: null, // Callback(sourceNode, data), return true, to enable dnd
+ dragStop: null, // Callback(sourceNode, data)
+ initHelper: null, // Callback(sourceNode, data)
+ updateHelper: null, // Callback(sourceNode, data)
+ // Events (drop support)
+ dragEnter: null, // Callback(targetNode, data)
+ dragOver: null, // Callback(targetNode, data)
+ dragExpand: null, // Callback(targetNode, data), return false to prevent autoExpand
+ dragDrop: null, // Callback(targetNode, data)
+ dragLeave: null, // Callback(targetNode, data)
+ },
+
+ treeInit: function(ctx) {
+ var tree = ctx.tree;
+ this._superApply(arguments);
+ // issue #270: draggable eats mousedown events
+ if (tree.options.dnd.dragStart) {
+ tree.$container.on("mousedown", function(event) {
+ // if( !tree.hasFocus() && ctx.options.dnd.focusOnClick ) {
+ if (ctx.options.dnd.focusOnClick) {
+ // #270
+ var node = $.ui.fancytree.getNode(event);
+ if (node) {
+ node.debug(
+ "Re-enable focus that was prevented by jQuery UI draggable."
+ );
+ // node.setFocus();
+ // $(node.span).closest(":tabbable").focus();
+ // $(event.target).trigger("focus");
+ // $(event.target).closest(":tabbable").trigger("focus");
+ }
+ setTimeout(function() {
+ // #300
+ $(event.target)
+ .closest(":tabbable")
+ .focus();
+ }, 10);
+ }
+ });
+ }
+ _initDragAndDrop(tree);
+ },
+ /* Display drop marker according to hitMode ('after', 'before', 'over'). */
+ _setDndStatus: function(
+ sourceNode,
+ targetNode,
+ helper,
+ hitMode,
+ accept
+ ) {
+ var markerOffsetX,
+ pos,
+ markerAt = "center",
+ instData = this._local,
+ dndOpt = this.options.dnd,
+ glyphOpt = this.options.glyph,
+ $source = sourceNode ? $(sourceNode.span) : null,
+ $target = $(targetNode.span),
+ $targetTitle = $target.find("span.fancytree-title");
+
+ if (!instData.$dropMarker) {
+ instData.$dropMarker = $(
+ "
"
+ )
+ .hide()
+ .css({ "z-index": 1000 })
+ .prependTo($(this.$div).parent());
+ // .prependTo("body");
+
+ if (glyphOpt) {
+ instData.$dropMarker.addClass(
+ glyphOpt.map._addClass + " " + glyphOpt.map.dropMarker
+ );
+ }
+ }
+ if (
+ hitMode === "after" ||
+ hitMode === "before" ||
+ hitMode === "over"
+ ) {
+ markerOffsetX = dndOpt.dropMarkerOffsetX || 0;
+ switch (hitMode) {
+ case "before":
+ markerAt = "top";
+ markerOffsetX += dndOpt.dropMarkerInsertOffsetX || 0;
+ break;
+ case "after":
+ markerAt = "bottom";
+ markerOffsetX += dndOpt.dropMarkerInsertOffsetX || 0;
+ break;
+ }
+
+ pos = {
+ my: "left" + offsetString(markerOffsetX) + " center",
+ at: "left " + markerAt,
+ of: $targetTitle,
+ };
+ if (this.options.rtl) {
+ pos.my = "right" + offsetString(-markerOffsetX) + " center";
+ pos.at = "right " + markerAt;
+ }
+ instData.$dropMarker
+ .toggleClass(classDropAfter, hitMode === "after")
+ .toggleClass(classDropOver, hitMode === "over")
+ .toggleClass(classDropBefore, hitMode === "before")
+ .toggleClass("fancytree-rtl", !!this.options.rtl)
+ .show()
+ .position($.ui.fancytree.fixPositionOptions(pos));
+ } else {
+ instData.$dropMarker.hide();
+ }
+ if ($source) {
+ $source
+ .toggleClass(classDropAccept, accept === true)
+ .toggleClass(classDropReject, accept === false);
+ }
+ $target
+ .toggleClass(
+ classDropTarget,
+ hitMode === "after" ||
+ hitMode === "before" ||
+ hitMode === "over"
+ )
+ .toggleClass(classDropAfter, hitMode === "after")
+ .toggleClass(classDropBefore, hitMode === "before")
+ .toggleClass(classDropAccept, accept === true)
+ .toggleClass(classDropReject, accept === false);
+
+ helper
+ .toggleClass(classDropAccept, accept === true)
+ .toggleClass(classDropReject, accept === false);
+ },
+
+ /*
+ * Handles drag'n'drop functionality.
+ *
+ * A standard jQuery drag-and-drop process may generate these calls:
+ *
+ * start:
+ * _onDragEvent("start", sourceNode, null, event, ui, draggable);
+ * drag:
+ * _onDragEvent("leave", prevTargetNode, sourceNode, event, ui, draggable);
+ * _onDragEvent("over", targetNode, sourceNode, event, ui, draggable);
+ * _onDragEvent("enter", targetNode, sourceNode, event, ui, draggable);
+ * stop:
+ * _onDragEvent("drop", targetNode, sourceNode, event, ui, draggable);
+ * _onDragEvent("leave", targetNode, sourceNode, event, ui, draggable);
+ * _onDragEvent("stop", sourceNode, null, event, ui, draggable);
+ */
+ _onDragEvent: function(
+ eventName,
+ node,
+ otherNode,
+ event,
+ ui,
+ draggable
+ ) {
+ // if(eventName !== "over"){
+ // this.debug("tree.ext.dnd._onDragEvent(%s, %o, %o) - %o", eventName, node, otherNode, this);
+ // }
+ var accept,
+ nodeOfs,
+ parentRect,
+ rect,
+ relPos,
+ relPos2,
+ enterResponse,
+ hitMode,
+ r,
+ opts = this.options,
+ dnd = opts.dnd,
+ ctx = this._makeHookContext(node, event, {
+ otherNode: otherNode,
+ ui: ui,
+ draggable: draggable,
+ }),
+ res = null,
+ self = this,
+ $nodeTag = $(node.span);
+
+ if (dnd.smartRevert) {
+ draggable.options.revert = "invalid";
+ }
+
+ switch (eventName) {
+ case "start":
+ if (node.isStatusNode()) {
+ res = false;
+ } else if (dnd.dragStart) {
+ res = dnd.dragStart(node, ctx);
+ }
+ if (res === false) {
+ this.debug("tree.dragStart() cancelled");
+ //draggable._clear();
+ // NOTE: the return value seems to be ignored (drag is not cancelled, when false is returned)
+ // TODO: call this._cancelDrag()?
+ ui.helper.trigger("mouseup").hide();
+ } else {
+ if (dnd.smartRevert) {
+ // #567, #593: fix revert position
+ // rect = node.li.getBoundingClientRect();
+ rect = node[
+ ctx.tree.nodeContainerAttrName
+ ].getBoundingClientRect();
+ parentRect = $(
+ draggable.options.appendTo
+ )[0].getBoundingClientRect();
+ draggable.originalPosition.left = Math.max(
+ 0,
+ rect.left - parentRect.left
+ );
+ draggable.originalPosition.top = Math.max(
+ 0,
+ rect.top - parentRect.top
+ );
+ }
+ $nodeTag.addClass("fancytree-drag-source");
+ // Register global handlers to allow cancel
+ $(document).on(
+ "keydown.fancytree-dnd,mousedown.fancytree-dnd",
+ function(event) {
+ // node.tree.debug("dnd global event", event.type, event.which);
+ if (
+ event.type === "keydown" &&
+ event.which === $.ui.keyCode.ESCAPE
+ ) {
+ self.ext.dnd._cancelDrag();
+ } else if (event.type === "mousedown") {
+ self.ext.dnd._cancelDrag();
+ }
+ }
+ );
+ }
+ break;
+
+ case "enter":
+ if (
+ dnd.preventRecursiveMoves &&
+ node.isDescendantOf(otherNode)
+ ) {
+ r = false;
+ } else {
+ r = dnd.dragEnter ? dnd.dragEnter(node, ctx) : null;
+ }
+ if (!r) {
+ // convert null, undefined, false to false
+ res = false;
+ } else if ($.isArray(r)) {
+ // TODO: also accept passing an object of this format directly
+ res = {
+ over: $.inArray("over", r) >= 0,
+ before: $.inArray("before", r) >= 0,
+ after: $.inArray("after", r) >= 0,
+ };
+ } else {
+ res = {
+ over: r === true || r === "over",
+ before: r === true || r === "before",
+ after: r === true || r === "after",
+ };
+ }
+ ui.helper.data("enterResponse", res);
+ // this.debug("helper.enterResponse: %o", res);
+ break;
+
+ case "over":
+ enterResponse = ui.helper.data("enterResponse");
+ hitMode = null;
+ if (enterResponse === false) {
+ // Don't call dragOver if onEnter returned false.
+ // break;
+ } else if (typeof enterResponse === "string") {
+ // Use hitMode from onEnter if provided.
+ hitMode = enterResponse;
+ } else {
+ // Calculate hitMode from relative cursor position.
+ nodeOfs = $nodeTag.offset();
+ relPos = {
+ x: event.pageX - nodeOfs.left,
+ y: event.pageY - nodeOfs.top,
+ };
+ relPos2 = {
+ x: relPos.x / $nodeTag.width(),
+ y: relPos.y / $nodeTag.height(),
+ };
+
+ if (enterResponse.after && relPos2.y > 0.75) {
+ hitMode = "after";
+ } else if (
+ !enterResponse.over &&
+ enterResponse.after &&
+ relPos2.y > 0.5
+ ) {
+ hitMode = "after";
+ } else if (enterResponse.before && relPos2.y <= 0.25) {
+ hitMode = "before";
+ } else if (
+ !enterResponse.over &&
+ enterResponse.before &&
+ relPos2.y <= 0.5
+ ) {
+ hitMode = "before";
+ } else if (enterResponse.over) {
+ hitMode = "over";
+ }
+ // Prevent no-ops like 'before source node'
+ // TODO: these are no-ops when moving nodes, but not in copy mode
+ if (dnd.preventVoidMoves) {
+ if (node === otherNode) {
+ this.debug(
+ " drop over source node prevented"
+ );
+ hitMode = null;
+ } else if (
+ hitMode === "before" &&
+ otherNode &&
+ node === otherNode.getNextSibling()
+ ) {
+ this.debug(
+ " drop after source node prevented"
+ );
+ hitMode = null;
+ } else if (
+ hitMode === "after" &&
+ otherNode &&
+ node === otherNode.getPrevSibling()
+ ) {
+ this.debug(
+ " drop before source node prevented"
+ );
+ hitMode = null;
+ } else if (
+ hitMode === "over" &&
+ otherNode &&
+ otherNode.parent === node &&
+ otherNode.isLastSibling()
+ ) {
+ this.debug(
+ " drop last child over own parent prevented"
+ );
+ hitMode = null;
+ }
+ }
+ // this.debug("hitMode: %s - %s - %s", hitMode, (node.parent === otherNode), node.isLastSibling());
+ ui.helper.data("hitMode", hitMode);
+ }
+ // Auto-expand node (only when 'over' the node, not 'before', or 'after')
+ if (
+ hitMode !== "before" &&
+ hitMode !== "after" &&
+ dnd.autoExpandMS &&
+ node.hasChildren() !== false &&
+ !node.expanded &&
+ (!dnd.dragExpand || dnd.dragExpand(node, ctx) !== false)
+ ) {
+ node.scheduleAction("expand", dnd.autoExpandMS);
+ }
+ if (hitMode && dnd.dragOver) {
+ // TODO: http://code.google.com/p/dynatree/source/detail?r=625
+ ctx.hitMode = hitMode;
+ res = dnd.dragOver(node, ctx);
+ }
+ accept = res !== false && hitMode !== null;
+ if (dnd.smartRevert) {
+ draggable.options.revert = !accept;
+ }
+ this._local._setDndStatus(
+ otherNode,
+ node,
+ ui.helper,
+ hitMode,
+ accept
+ );
+ break;
+
+ case "drop":
+ hitMode = ui.helper.data("hitMode");
+ if (hitMode && dnd.dragDrop) {
+ ctx.hitMode = hitMode;
+ dnd.dragDrop(node, ctx);
+ }
+ break;
+
+ case "leave":
+ // Cancel pending expand request
+ node.scheduleAction("cancel");
+ ui.helper.data("enterResponse", null);
+ ui.helper.data("hitMode", null);
+ this._local._setDndStatus(
+ otherNode,
+ node,
+ ui.helper,
+ "out",
+ undefined
+ );
+ if (dnd.dragLeave) {
+ dnd.dragLeave(node, ctx);
+ }
+ break;
+
+ case "stop":
+ $nodeTag.removeClass("fancytree-drag-source");
+ $(document).off(".fancytree-dnd");
+ if (dnd.dragStop) {
+ dnd.dragStop(node, ctx);
+ }
+ break;
+
+ default:
+ $.error("Unsupported drag event: " + eventName);
+ }
+ return res;
+ },
+
+ _cancelDrag: function() {
+ var dd = $.ui.ddmanager.current;
+ if (dd) {
+ dd.cancel();
+ }
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd5.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd5.js
new file mode 100644
index 0000000..bb84956
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.dnd5.js
@@ -0,0 +1,1151 @@
+/*!
+ * jquery.fancytree.dnd5.js
+ *
+ * Drag-and-drop support (native HTML5).
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+/*
+ #TODO
+ Compatiblity when dragging between *separate* windows:
+
+ Drag from Chrome Edge FF IE11 Safari
+ To Chrome ok ok ok NO ?
+ Edge ok ok ok NO ?
+ FF ok ok ok NO ?
+ IE 11 ok ok ok ok ?
+ Safari ? ? ? ? ok
+
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /******************************************************************************
+ * Private functions and variables
+ */
+ var FT = $.ui.fancytree,
+ isMac = /Mac/.test(navigator.platform),
+ classDragSource = "fancytree-drag-source",
+ classDragRemove = "fancytree-drag-remove",
+ classDropAccept = "fancytree-drop-accept",
+ classDropAfter = "fancytree-drop-after",
+ classDropBefore = "fancytree-drop-before",
+ classDropOver = "fancytree-drop-over",
+ classDropReject = "fancytree-drop-reject",
+ classDropTarget = "fancytree-drop-target",
+ nodeMimeType = "application/x-fancytree-node",
+ $dropMarker = null,
+ $dragImage,
+ $extraHelper,
+ SOURCE_NODE = null,
+ SOURCE_NODE_LIST = null,
+ $sourceList = null,
+ DRAG_ENTER_RESPONSE = null,
+ // SESSION_DATA = null, // plain object passed to events as `data`
+ SUGGESTED_DROP_EFFECT = null,
+ REQUESTED_DROP_EFFECT = null,
+ REQUESTED_EFFECT_ALLOWED = null,
+ LAST_HIT_MODE = null,
+ DRAG_OVER_STAMP = null; // Time when a node entered the 'over' hitmode
+
+ /* */
+ function _clearGlobals() {
+ DRAG_ENTER_RESPONSE = null;
+ DRAG_OVER_STAMP = null;
+ REQUESTED_DROP_EFFECT = null;
+ REQUESTED_EFFECT_ALLOWED = null;
+ SUGGESTED_DROP_EFFECT = null;
+ SOURCE_NODE = null;
+ SOURCE_NODE_LIST = null;
+ if ($sourceList) {
+ $sourceList.removeClass(classDragSource + " " + classDragRemove);
+ }
+ $sourceList = null;
+ if ($dropMarker) {
+ $dropMarker.hide();
+ }
+ // Take this badge off of me - I can't use it anymore:
+ if ($extraHelper) {
+ $extraHelper.remove();
+ $extraHelper = null;
+ }
+ }
+
+ /* Convert number to string and prepend +/-; return empty string for 0.*/
+ function offsetString(n) {
+ // eslint-disable-next-line no-nested-ternary
+ return n === 0 ? "" : n > 0 ? "+" + n : "" + n;
+ }
+
+ /* Convert a dragEnter() or dragOver() response to a canonical form.
+ * Return false or plain object
+ * @param {string|object|boolean} r
+ * @return {object|false}
+ */
+ function normalizeDragEnterResponse(r) {
+ var res;
+
+ if (!r) {
+ return false;
+ }
+ if ($.isPlainObject(r)) {
+ res = {
+ over: !!r.over,
+ before: !!r.before,
+ after: !!r.after,
+ };
+ } else if ($.isArray(r)) {
+ res = {
+ over: $.inArray("over", r) >= 0,
+ before: $.inArray("before", r) >= 0,
+ after: $.inArray("after", r) >= 0,
+ };
+ } else {
+ res = {
+ over: r === true || r === "over",
+ before: r === true || r === "before",
+ after: r === true || r === "after",
+ };
+ }
+ if (Object.keys(res).length === 0) {
+ return false;
+ }
+ // if( Object.keys(res).length === 1 ) {
+ // res.unique = res[0];
+ // }
+ return res;
+ }
+
+ /* Convert a dataTransfer.effectAllowed to a canonical form.
+ * Return false or plain object
+ * @param {string|boolean} r
+ * @return {object|false}
+ */
+ // function normalizeEffectAllowed(r) {
+ // if (!r || r === "none") {
+ // return false;
+ // }
+ // var all = r === "all",
+ // res = {
+ // copy: all || /copy/i.test(r),
+ // link: all || /link/i.test(r),
+ // move: all || /move/i.test(r),
+ // };
+
+ // return res;
+ // }
+
+ /* Implement auto scrolling when drag cursor is in top/bottom area of scroll parent. */
+ function autoScroll(tree, event) {
+ var spOfs,
+ scrollTop,
+ delta,
+ dndOpts = tree.options.dnd5,
+ sp = tree.$scrollParent[0],
+ sensitivity = dndOpts.scrollSensitivity,
+ speed = dndOpts.scrollSpeed,
+ scrolled = 0;
+
+ if (sp !== document && sp.tagName !== "HTML") {
+ spOfs = tree.$scrollParent.offset();
+ scrollTop = sp.scrollTop;
+ if (spOfs.top + sp.offsetHeight - event.pageY < sensitivity) {
+ delta =
+ sp.scrollHeight -
+ tree.$scrollParent.innerHeight() -
+ scrollTop;
+ // console.log ("sp.offsetHeight: " + sp.offsetHeight
+ // + ", spOfs.top: " + spOfs.top
+ // + ", scrollTop: " + scrollTop
+ // + ", innerHeight: " + tree.$scrollParent.innerHeight()
+ // + ", scrollHeight: " + sp.scrollHeight
+ // + ", delta: " + delta
+ // );
+ if (delta > 0) {
+ sp.scrollTop = scrolled = scrollTop + speed;
+ }
+ } else if (scrollTop > 0 && event.pageY - spOfs.top < sensitivity) {
+ sp.scrollTop = scrolled = scrollTop - speed;
+ }
+ } else {
+ scrollTop = $(document).scrollTop();
+ if (scrollTop > 0 && event.pageY - scrollTop < sensitivity) {
+ scrolled = scrollTop - speed;
+ $(document).scrollTop(scrolled);
+ } else if (
+ $(window).height() - (event.pageY - scrollTop) <
+ sensitivity
+ ) {
+ scrolled = scrollTop + speed;
+ $(document).scrollTop(scrolled);
+ }
+ }
+ if (scrolled) {
+ tree.debug("autoScroll: " + scrolled + "px");
+ }
+ return scrolled;
+ }
+
+ /* Guess dropEffect from modifier keys.
+ * Using rules suggested here:
+ * https://ux.stackexchange.com/a/83769
+ * @returns
+ * 'copy', 'link', 'move', or 'none'
+ */
+ function evalEffectModifiers(tree, event, effectDefault) {
+ var res = effectDefault;
+
+ if (isMac) {
+ if (event.metaKey && event.altKey) {
+ // Mac: [Control] + [Option]
+ res = "link";
+ } else if (event.ctrlKey) {
+ // Chrome on Mac: [Control]
+ res = "link";
+ } else if (event.metaKey) {
+ // Mac: [Command]
+ res = "move";
+ } else if (event.altKey) {
+ // Mac: [Option]
+ res = "copy";
+ }
+ } else {
+ if (event.ctrlKey) {
+ // Windows: [Ctrl]
+ res = "copy";
+ } else if (event.shiftKey) {
+ // Windows: [Shift]
+ res = "move";
+ } else if (event.altKey) {
+ // Windows: [Alt]
+ res = "link";
+ }
+ }
+ if (res !== SUGGESTED_DROP_EFFECT) {
+ tree.info(
+ "evalEffectModifiers: " +
+ event.type +
+ " - evalEffectModifiers(): " +
+ SUGGESTED_DROP_EFFECT +
+ " -> " +
+ res
+ );
+ }
+ SUGGESTED_DROP_EFFECT = res;
+ // tree.debug("evalEffectModifiers: " + res);
+ return res;
+ }
+ /*
+ * Check if the previous callback (dragEnter, dragOver, ...) has changed
+ * the `data` object and apply those settings.
+ *
+ * Safari:
+ * It seems that `dataTransfer.dropEffect` can only be set on dragStart, and will remain
+ * even if the cursor changes when [Alt] or [Ctrl] are pressed (?)
+ * Using rules suggested here:
+ * https://ux.stackexchange.com/a/83769
+ * @returns
+ * 'copy', 'link', 'move', or 'none'
+ */
+ function prepareDropEffectCallback(event, data) {
+ var tree = data.tree,
+ dataTransfer = data.dataTransfer;
+
+ if (event.type === "dragstart") {
+ data.effectAllowed = tree.options.dnd5.effectAllowed;
+ data.dropEffect = tree.options.dnd5.dropEffectDefault;
+ } else {
+ data.effectAllowed = REQUESTED_EFFECT_ALLOWED;
+ data.dropEffect = REQUESTED_DROP_EFFECT;
+ }
+ data.dropEffectSuggested = evalEffectModifiers(
+ tree,
+ event,
+ tree.options.dnd5.dropEffectDefault
+ );
+ data.isMove = data.dropEffect === "move";
+ data.files = dataTransfer.files || [];
+
+ // if (REQUESTED_EFFECT_ALLOWED !== dataTransfer.effectAllowed) {
+ // tree.warn(
+ // "prepareDropEffectCallback(" +
+ // event.type +
+ // "): dataTransfer.effectAllowed changed from " +
+ // REQUESTED_EFFECT_ALLOWED +
+ // " -> " +
+ // dataTransfer.effectAllowed
+ // );
+ // }
+ // if (REQUESTED_DROP_EFFECT !== dataTransfer.dropEffect) {
+ // tree.warn(
+ // "prepareDropEffectCallback(" +
+ // event.type +
+ // "): dataTransfer.dropEffect changed from requested " +
+ // REQUESTED_DROP_EFFECT +
+ // " to " +
+ // dataTransfer.dropEffect
+ // );
+ // }
+ }
+
+ function applyDropEffectCallback(event, data, allowDrop) {
+ var tree = data.tree,
+ dataTransfer = data.dataTransfer;
+
+ if (
+ event.type !== "dragstart" &&
+ REQUESTED_EFFECT_ALLOWED !== data.effectAllowed
+ ) {
+ tree.warn(
+ "effectAllowed should only be changed in dragstart event: " +
+ event.type +
+ ": data.effectAllowed changed from " +
+ REQUESTED_EFFECT_ALLOWED +
+ " -> " +
+ data.effectAllowed
+ );
+ }
+
+ if (allowDrop === false) {
+ tree.info("applyDropEffectCallback: allowDrop === false");
+ data.effectAllowed = "none";
+ data.dropEffect = "none";
+ }
+ // if (REQUESTED_DROP_EFFECT !== data.dropEffect) {
+ // tree.debug(
+ // "applyDropEffectCallback(" +
+ // event.type +
+ // "): data.dropEffect changed from previous " +
+ // REQUESTED_DROP_EFFECT +
+ // " to " +
+ // data.dropEffect
+ // );
+ // }
+
+ data.isMove = data.dropEffect === "move";
+ // data.isMove = data.dropEffectSuggested === "move";
+
+ // `effectAllowed` must only be defined in dragstart event, so we
+ // store it in a global variable for reference
+ if (event.type === "dragstart") {
+ REQUESTED_EFFECT_ALLOWED = data.effectAllowed;
+ REQUESTED_DROP_EFFECT = data.dropEffect;
+ }
+
+ // if (REQUESTED_DROP_EFFECT !== dataTransfer.dropEffect) {
+ // data.tree.info(
+ // "applyDropEffectCallback(" +
+ // event.type +
+ // "): dataTransfer.dropEffect changed from " +
+ // REQUESTED_DROP_EFFECT +
+ // " -> " +
+ // dataTransfer.dropEffect
+ // );
+ // }
+ dataTransfer.effectAllowed = REQUESTED_EFFECT_ALLOWED;
+ dataTransfer.dropEffect = REQUESTED_DROP_EFFECT;
+
+ // tree.debug(
+ // "applyDropEffectCallback(" +
+ // event.type +
+ // "): set " +
+ // dataTransfer.dropEffect +
+ // "/" +
+ // dataTransfer.effectAllowed
+ // );
+ // if (REQUESTED_DROP_EFFECT !== dataTransfer.dropEffect) {
+ // data.tree.warn(
+ // "applyDropEffectCallback(" +
+ // event.type +
+ // "): could not set dataTransfer.dropEffect to " +
+ // REQUESTED_DROP_EFFECT +
+ // ": got " +
+ // dataTransfer.dropEffect
+ // );
+ // }
+ return REQUESTED_DROP_EFFECT;
+ }
+
+ /* Handle dragover event (fired every x ms) on valid drop targets.
+ *
+ * - Auto-scroll when cursor is in border regions
+ * - Apply restrictioan like 'preventVoidMoves'
+ * - Calculate hit mode
+ * - Calculate drop effect
+ * - Trigger dragOver() callback to let user modify hit mode and drop effect
+ * - Adjust the drop marker accordingly
+ *
+ * @returns hitMode
+ */
+ function handleDragOver(event, data) {
+ // Implement auto-scrolling
+ if (data.options.dnd5.scroll) {
+ autoScroll(data.tree, event);
+ }
+ // Bail out with previous response if we get an invalid dragover
+ if (!data.node) {
+ data.tree.warn("Ignored dragover for non-node"); //, event, data);
+ return LAST_HIT_MODE;
+ }
+
+ var markerOffsetX,
+ nodeOfs,
+ pos,
+ relPosY,
+ hitMode = null,
+ tree = data.tree,
+ options = tree.options,
+ dndOpts = options.dnd5,
+ targetNode = data.node,
+ sourceNode = data.otherNode,
+ markerAt = "center",
+ $target = $(targetNode.span),
+ $targetTitle = $target.find("span.fancytree-title");
+
+ if (DRAG_ENTER_RESPONSE === false) {
+ tree.debug("Ignored dragover, since dragenter returned false.");
+ return false;
+ } else if (typeof DRAG_ENTER_RESPONSE === "string") {
+ $.error("assert failed: dragenter returned string");
+ }
+ // Calculate hitMode from relative cursor position.
+ nodeOfs = $target.offset();
+ relPosY = (event.pageY - nodeOfs.top) / $target.height();
+ if (event.pageY === undefined) {
+ tree.warn("event.pageY is undefined: see issue #1013.");
+ }
+
+ if (DRAG_ENTER_RESPONSE.after && relPosY > 0.75) {
+ hitMode = "after";
+ } else if (
+ !DRAG_ENTER_RESPONSE.over &&
+ DRAG_ENTER_RESPONSE.after &&
+ relPosY > 0.5
+ ) {
+ hitMode = "after";
+ } else if (DRAG_ENTER_RESPONSE.before && relPosY <= 0.25) {
+ hitMode = "before";
+ } else if (
+ !DRAG_ENTER_RESPONSE.over &&
+ DRAG_ENTER_RESPONSE.before &&
+ relPosY <= 0.5
+ ) {
+ hitMode = "before";
+ } else if (DRAG_ENTER_RESPONSE.over) {
+ hitMode = "over";
+ }
+ // Prevent no-ops like 'before source node'
+ // TODO: these are no-ops when moving nodes, but not in copy mode
+ if (dndOpts.preventVoidMoves && data.dropEffect === "move") {
+ if (targetNode === sourceNode) {
+ targetNode.debug("Drop over source node prevented.");
+ hitMode = null;
+ } else if (
+ hitMode === "before" &&
+ sourceNode &&
+ targetNode === sourceNode.getNextSibling()
+ ) {
+ targetNode.debug("Drop after source node prevented.");
+ hitMode = null;
+ } else if (
+ hitMode === "after" &&
+ sourceNode &&
+ targetNode === sourceNode.getPrevSibling()
+ ) {
+ targetNode.debug("Drop before source node prevented.");
+ hitMode = null;
+ } else if (
+ hitMode === "over" &&
+ sourceNode &&
+ sourceNode.parent === targetNode &&
+ sourceNode.isLastSibling()
+ ) {
+ targetNode.debug("Drop last child over own parent prevented.");
+ hitMode = null;
+ }
+ }
+ // Let callback modify the calculated hitMode
+ data.hitMode = hitMode;
+ if (hitMode && dndOpts.dragOver) {
+ prepareDropEffectCallback(event, data);
+ dndOpts.dragOver(targetNode, data);
+ var allowDrop = !!hitMode;
+ applyDropEffectCallback(event, data, allowDrop);
+ hitMode = data.hitMode;
+ }
+ LAST_HIT_MODE = hitMode;
+ //
+ if (hitMode === "after" || hitMode === "before" || hitMode === "over") {
+ markerOffsetX = dndOpts.dropMarkerOffsetX || 0;
+ switch (hitMode) {
+ case "before":
+ markerAt = "top";
+ markerOffsetX += dndOpts.dropMarkerInsertOffsetX || 0;
+ break;
+ case "after":
+ markerAt = "bottom";
+ markerOffsetX += dndOpts.dropMarkerInsertOffsetX || 0;
+ break;
+ }
+
+ pos = {
+ my: "left" + offsetString(markerOffsetX) + " center",
+ at: "left " + markerAt,
+ of: $targetTitle,
+ };
+ if (options.rtl) {
+ pos.my = "right" + offsetString(-markerOffsetX) + " center";
+ pos.at = "right " + markerAt;
+ // console.log("rtl", pos);
+ }
+ $dropMarker
+ .toggleClass(classDropAfter, hitMode === "after")
+ .toggleClass(classDropOver, hitMode === "over")
+ .toggleClass(classDropBefore, hitMode === "before")
+ .show()
+ .position(FT.fixPositionOptions(pos));
+ } else {
+ $dropMarker.hide();
+ // console.log("hide dropmarker")
+ }
+
+ $(targetNode.span)
+ .toggleClass(
+ classDropTarget,
+ hitMode === "after" ||
+ hitMode === "before" ||
+ hitMode === "over"
+ )
+ .toggleClass(classDropAfter, hitMode === "after")
+ .toggleClass(classDropBefore, hitMode === "before")
+ .toggleClass(classDropAccept, hitMode === "over")
+ .toggleClass(classDropReject, hitMode === false);
+
+ return hitMode;
+ }
+
+ /*
+ * Handle dragstart drag dragend events on the container
+ */
+ function onDragEvent(event) {
+ var json,
+ tree = this,
+ dndOpts = tree.options.dnd5,
+ node = FT.getNode(event),
+ dataTransfer =
+ event.dataTransfer || event.originalEvent.dataTransfer,
+ data = {
+ tree: tree,
+ node: node,
+ options: tree.options,
+ originalEvent: event.originalEvent,
+ widget: tree.widget,
+ dataTransfer: dataTransfer,
+ useDefaultImage: true,
+ dropEffect: undefined,
+ dropEffectSuggested: undefined,
+ effectAllowed: undefined, // set by dragstart
+ files: undefined, // only for drop events
+ isCancelled: undefined, // set by dragend
+ isMove: undefined,
+ };
+
+ switch (event.type) {
+ case "dragstart":
+ if (!node) {
+ tree.info("Ignored dragstart on a non-node.");
+ return false;
+ }
+ // Store current source node in different formats
+ SOURCE_NODE = node;
+
+ // Also optionally store selected nodes
+ if (dndOpts.multiSource === false) {
+ SOURCE_NODE_LIST = [node];
+ } else if (dndOpts.multiSource === true) {
+ SOURCE_NODE_LIST = tree.getSelectedNodes();
+ if (!node.isSelected()) {
+ SOURCE_NODE_LIST.unshift(node);
+ }
+ } else {
+ SOURCE_NODE_LIST = dndOpts.multiSource(node, data);
+ }
+ // Cache as array of jQuery objects for faster access:
+ $sourceList = $(
+ $.map(SOURCE_NODE_LIST, function(n) {
+ return n.span;
+ })
+ );
+ // Set visual feedback
+ $sourceList.addClass(classDragSource);
+
+ // Set payload
+ // Note:
+ // Transfer data is only accessible on dragstart and drop!
+ // For all other events the formats and kinds in the drag
+ // data store list of items representing dragged data can be
+ // enumerated, but the data itself is unavailable and no new
+ // data can be added.
+ var nodeData = node.toDict();
+ nodeData.treeId = node.tree._id;
+ json = JSON.stringify(nodeData);
+ try {
+ dataTransfer.setData(nodeMimeType, json);
+ dataTransfer.setData("text/html", $(node.span).html());
+ dataTransfer.setData("text/plain", node.title);
+ } catch (ex) {
+ // IE only accepts 'text' type
+ tree.warn(
+ "Could not set data (IE only accepts 'text') - " + ex
+ );
+ }
+ // We always need to set the 'text' type if we want to drag
+ // Because IE 11 only accepts this single type.
+ // If we pass JSON here, IE can can access all node properties,
+ // even when the source lives in another window. (D'n'd inside
+ // the same window will always work.)
+ // The drawback is, that in this case ALL browsers will see
+ // the JSON representation as 'text', so dragging
+ // to a text field will insert the JSON string instead of
+ // the node title.
+ if (dndOpts.setTextTypeJson) {
+ dataTransfer.setData("text", json);
+ } else {
+ dataTransfer.setData("text", node.title);
+ }
+
+ // Set the allowed drag modes (combinations of move, copy, and link)
+ // (effectAllowed can only be set in the dragstart event.)
+ // This can be overridden in the dragStart() callback
+ prepareDropEffectCallback(event, data);
+
+ // Let user cancel or modify above settings
+ // Realize potential changes by previous callback
+ if (dndOpts.dragStart(node, data) === false) {
+ // Cancel dragging
+ // dataTransfer.dropEffect = "none";
+ _clearGlobals();
+ return false;
+ }
+ applyDropEffectCallback(event, data);
+
+ // Unless user set `data.useDefaultImage` to false in dragStart,
+ // generata a default drag image now:
+ $extraHelper = null;
+
+ if (data.useDefaultImage) {
+ // Set the title as drag image (otherwise it would contain the expander)
+ $dragImage = $(node.span).find(".fancytree-title");
+
+ if (SOURCE_NODE_LIST && SOURCE_NODE_LIST.length > 1) {
+ // Add a counter badge to node title if dragging more than one node.
+ // We want this, because the element that is used as drag image
+ // must be *visible* in the DOM, so we cannot create some hidden
+ // custom markup.
+ // See https://kryogenix.org/code/browser/custom-drag-image.html
+ // Also, since IE 11 and Edge don't support setDragImage() alltogether,
+ // it gives som feedback to the user.
+ // The badge will be removed later on drag end.
+ $extraHelper = $(
+ "").appendTo(this.$container);
+ this.$scrollParent = $temp.scrollParent();
+ $temp.remove();
+
+ $dropMarker = $("#fancytree-drop-marker");
+ if (!$dropMarker.length) {
+ $dropMarker = $("
")
+ .hide()
+ .css({
+ "z-index": 1000,
+ // Drop marker should not steal dragenter/dragover events:
+ "pointer-events": "none",
+ })
+ .prependTo(dndOpts.dropMarkerParent);
+ if (glyph) {
+ FT.setSpanIcon(
+ $dropMarker[0],
+ glyph.map._addClass,
+ glyph.map.dropMarker
+ );
+ }
+ }
+ $dropMarker.toggleClass("fancytree-rtl", !!opts.rtl);
+
+ // Enable drag support if dragStart() is specified:
+ if (dndOpts.dragStart) {
+ // Bind drag event handlers
+ tree.$container.on(
+ "dragstart drag dragend",
+ onDragEvent.bind(tree)
+ );
+ }
+ // Enable drop support if dragEnter() is specified:
+ if (dndOpts.dragEnter) {
+ // Bind drop event handlers
+ tree.$container.on(
+ "dragenter dragover dragleave drop",
+ onDropEvent.bind(tree)
+ );
+ }
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.edit.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.edit.js
new file mode 100644
index 0000000..adbe038
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.edit.js
@@ -0,0 +1,402 @@
+/*!
+ * jquery.fancytree.edit.js
+ *
+ * Make node titles editable.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /*******************************************************************************
+ * Private functions and variables
+ */
+
+ var isMac = /Mac/.test(navigator.platform),
+ escapeHtml = $.ui.fancytree.escapeHtml,
+ unescapeHtml = $.ui.fancytree.unescapeHtml;
+
+ /**
+ * [ext-edit] Start inline editing of current node title.
+ *
+ * @alias FancytreeNode#editStart
+ * @requires Fancytree
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.editStart = function() {
+ var $input,
+ node = this,
+ tree = this.tree,
+ local = tree.ext.edit,
+ instOpts = tree.options.edit,
+ $title = $(".fancytree-title", node.span),
+ eventData = {
+ node: node,
+ tree: tree,
+ options: tree.options,
+ isNew: $(node[tree.statusClassPropName]).hasClass(
+ "fancytree-edit-new"
+ ),
+ orgTitle: node.title,
+ input: null,
+ dirty: false,
+ };
+
+ // beforeEdit may want to modify the title before editing
+ if (
+ instOpts.beforeEdit.call(
+ node,
+ { type: "beforeEdit" },
+ eventData
+ ) === false
+ ) {
+ return false;
+ }
+ $.ui.fancytree.assert(!local.currentNode, "recursive edit");
+ local.currentNode = this;
+ local.eventData = eventData;
+
+ // Disable standard Fancytree mouse- and key handling
+ tree.widget._unbind();
+
+ local.lastDraggableAttrValue = node.span.draggable;
+ if (local.lastDraggableAttrValue) {
+ node.span.draggable = false;
+ }
+
+ // #116: ext-dnd prevents the blur event, so we have to catch outer clicks
+ $(document).on("mousedown.fancytree-edit", function(event) {
+ if (!$(event.target).hasClass("fancytree-edit-input")) {
+ node.editEnd(true, event);
+ }
+ });
+
+ // Replace node with
")
+ .html(s)
+ .text();
+ }
+ return s;
+ }
+
+ $.ui.fancytree._FancytreeClass.prototype._applyFilterImpl = function(
+ filter,
+ branchMode,
+ _opts
+ ) {
+ var match,
+ statusNode,
+ re,
+ reHighlight,
+ temp,
+ prevEnableUpdate,
+ count = 0,
+ treeOpts = this.options,
+ escapeTitles = treeOpts.escapeTitles,
+ prevAutoCollapse = treeOpts.autoCollapse,
+ opts = $.extend({}, treeOpts.filter, _opts),
+ hideMode = opts.mode === "hide",
+ leavesOnly = !!opts.leavesOnly && !branchMode;
+
+ // Default to 'match title substring (not case sensitive)'
+ if (typeof filter === "string") {
+ if (filter === "") {
+ this.warn(
+ "Fancytree passing an empty string as a filter is handled as clearFilter()."
+ );
+ this.clearFilter();
+ return;
+ }
+ if (opts.fuzzy) {
+ // See https://codereview.stackexchange.com/questions/23899/faster-javascript-fuzzy-string-matching-function/23905#23905
+ // and http://www.quora.com/How-is-the-fuzzy-search-algorithm-in-Sublime-Text-designed
+ // and http://www.dustindiaz.com/autocomplete-fuzzy-matching
+ match = filter.split("").reduce(function(a, b) {
+ return a + "[^" + b + "]*" + b;
+ });
+ } else {
+ match = _escapeRegex(filter); // make sure a '.' is treated literally
+ }
+ re = new RegExp(".*" + match + ".*", "i");
+ reHighlight = new RegExp(_escapeRegex(filter), "gi");
+ filter = function(node) {
+ if (!node.title) {
+ return false;
+ }
+ var text = escapeTitles
+ ? node.title
+ : extractHtmlText(node.title),
+ res = !!re.test(text);
+
+ if (res && opts.highlight) {
+ if (escapeTitles) {
+ // #740: we must not apply the marks to escaped entity names, e.g. `"`
+ // Use some exotic characters to mark matches:
+ temp = text.replace(reHighlight, function(s) {
+ return "\uFFF7" + s + "\uFFF8";
+ });
+ // now we can escape the title...
+ node.titleWithHighlight = escapeHtml(temp)
+ // ... and finally insert the desired `` tags
+ .replace(/\uFFF7/g, "")
+ .replace(/\uFFF8/g, " ");
+ } else {
+ node.titleWithHighlight = text.replace(
+ reHighlight,
+ function(s) {
+ return "" + s + " ";
+ }
+ );
+ }
+ // node.debug("filter", escapeTitles, text, node.titleWithHighlight);
+ }
+ return res;
+ };
+ }
+
+ this.enableFilter = true;
+ this.lastFilterArgs = arguments;
+
+ prevEnableUpdate = this.enableUpdate(false);
+
+ this.$div.addClass("fancytree-ext-filter");
+ if (hideMode) {
+ this.$div.addClass("fancytree-ext-filter-hide");
+ } else {
+ this.$div.addClass("fancytree-ext-filter-dimm");
+ }
+ this.$div.toggleClass(
+ "fancytree-ext-filter-hide-expanders",
+ !!opts.hideExpanders
+ );
+ // Reset current filter
+ this.rootNode.subMatchCount = 0;
+ this.visit(function(node) {
+ delete node.match;
+ delete node.titleWithHighlight;
+ node.subMatchCount = 0;
+ });
+ statusNode = this.getRootNode()._findDirectChild(KeyNoData);
+ if (statusNode) {
+ statusNode.remove();
+ }
+
+ // Adjust node.hide, .match, and .subMatchCount properties
+ treeOpts.autoCollapse = false; // #528
+
+ this.visit(function(node) {
+ if (leavesOnly && node.children != null) {
+ return;
+ }
+ var res = filter(node),
+ matchedByBranch = false;
+
+ if (res === "skip") {
+ node.visit(function(c) {
+ c.match = false;
+ }, true);
+ return "skip";
+ }
+ if (!res && (branchMode || res === "branch") && node.parent.match) {
+ res = true;
+ matchedByBranch = true;
+ }
+ if (res) {
+ count++;
+ node.match = true;
+ node.visitParents(function(p) {
+ if (p !== node) {
+ p.subMatchCount += 1;
+ }
+ // Expand match (unless this is no real match, but only a node in a matched branch)
+ if (opts.autoExpand && !matchedByBranch && !p.expanded) {
+ p.setExpanded(true, {
+ noAnimation: true,
+ noEvents: true,
+ scrollIntoView: false,
+ });
+ p._filterAutoExpanded = true;
+ }
+ }, true);
+ }
+ });
+ treeOpts.autoCollapse = prevAutoCollapse;
+
+ if (count === 0 && opts.nodata && hideMode) {
+ statusNode = opts.nodata;
+ if ($.isFunction(statusNode)) {
+ statusNode = statusNode();
+ }
+ if (statusNode === true) {
+ statusNode = {};
+ } else if (typeof statusNode === "string") {
+ statusNode = { title: statusNode };
+ }
+ statusNode = $.extend(
+ {
+ statusNodeType: "nodata",
+ key: KeyNoData,
+ title: this.options.strings.noData,
+ },
+ statusNode
+ );
+
+ this.getRootNode().addNode(statusNode).match = true;
+ }
+ // Redraw whole tree
+ this._callHook("treeStructureChanged", this, "applyFilter");
+ // this.render();
+ this.enableUpdate(prevEnableUpdate);
+ return count;
+ };
+
+ /**
+ * [ext-filter] Dimm or hide nodes.
+ *
+ * @param {function | string} filter
+ * @param {boolean} [opts={autoExpand: false, leavesOnly: false}]
+ * @returns {integer} count
+ * @alias Fancytree#filterNodes
+ * @requires jquery.fancytree.filter.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.filterNodes = function(
+ filter,
+ opts
+ ) {
+ if (typeof opts === "boolean") {
+ opts = { leavesOnly: opts };
+ this.warn(
+ "Fancytree.filterNodes() leavesOnly option is deprecated since 2.9.0 / 2015-04-19. Use opts.leavesOnly instead."
+ );
+ }
+ return this._applyFilterImpl(filter, false, opts);
+ };
+
+ /**
+ * [ext-filter] Dimm or hide whole branches.
+ *
+ * @param {function | string} filter
+ * @param {boolean} [opts={autoExpand: false}]
+ * @returns {integer} count
+ * @alias Fancytree#filterBranches
+ * @requires jquery.fancytree.filter.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.filterBranches = function(
+ filter,
+ opts
+ ) {
+ return this._applyFilterImpl(filter, true, opts);
+ };
+
+ /**
+ * [ext-filter] Reset the filter.
+ *
+ * @alias Fancytree#clearFilter
+ * @requires jquery.fancytree.filter.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.clearFilter = function() {
+ var $title,
+ statusNode = this.getRootNode()._findDirectChild(KeyNoData),
+ escapeTitles = this.options.escapeTitles,
+ enhanceTitle = this.options.enhanceTitle,
+ prevEnableUpdate = this.enableUpdate(false);
+
+ if (statusNode) {
+ statusNode.remove();
+ }
+ // we also counted root node's subMatchCount
+ delete this.rootNode.match;
+ delete this.rootNode.subMatchCount;
+
+ this.visit(function(node) {
+ if (node.match && node.span) {
+ // #491, #601
+ $title = $(node.span).find(">span.fancytree-title");
+ if (escapeTitles) {
+ $title.text(node.title);
+ } else {
+ $title.html(node.title);
+ }
+ if (enhanceTitle) {
+ enhanceTitle(
+ { type: "enhanceTitle" },
+ { node: node, $title: $title }
+ );
+ }
+ }
+ delete node.match;
+ delete node.subMatchCount;
+ delete node.titleWithHighlight;
+ if (node.$subMatchBadge) {
+ node.$subMatchBadge.remove();
+ delete node.$subMatchBadge;
+ }
+ if (node._filterAutoExpanded && node.expanded) {
+ node.setExpanded(false, {
+ noAnimation: true,
+ noEvents: true,
+ scrollIntoView: false,
+ });
+ }
+ delete node._filterAutoExpanded;
+ });
+ this.enableFilter = false;
+ this.lastFilterArgs = null;
+ this.$div.removeClass(
+ "fancytree-ext-filter fancytree-ext-filter-dimm fancytree-ext-filter-hide"
+ );
+ this._callHook("treeStructureChanged", this, "clearFilter");
+ // this.render();
+ this.enableUpdate(prevEnableUpdate);
+ };
+
+ /**
+ * [ext-filter] Return true if a filter is currently applied.
+ *
+ * @returns {Boolean}
+ * @alias Fancytree#isFilterActive
+ * @requires jquery.fancytree.filter.js
+ * @since 2.13
+ */
+ $.ui.fancytree._FancytreeClass.prototype.isFilterActive = function() {
+ return !!this.enableFilter;
+ };
+
+ /**
+ * [ext-filter] Return true if this node is matched by current filter (or no filter is active).
+ *
+ * @returns {Boolean}
+ * @alias FancytreeNode#isMatched
+ * @requires jquery.fancytree.filter.js
+ * @since 2.13
+ */
+ $.ui.fancytree._FancytreeNodeClass.prototype.isMatched = function() {
+ return !(this.tree.enableFilter && !this.match);
+ };
+
+ /*******************************************************************************
+ * Extension code
+ */
+ $.ui.fancytree.registerExtension({
+ name: "filter",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {
+ autoApply: true, // Re-apply last filter if lazy data is loaded
+ autoExpand: false, // Expand all branches that contain matches while filtered
+ counter: true, // Show a badge with number of matching child nodes near parent icons
+ fuzzy: false, // Match single characters in order, e.g. 'fb' will match 'FooBar'
+ hideExpandedCounter: true, // Hide counter badge if parent is expanded
+ hideExpanders: false, // Hide expanders if all child nodes are hidden by filter
+ highlight: true, // Highlight matches by wrapping inside tags
+ leavesOnly: false, // Match end nodes only
+ nodata: true, // Display a 'no data' status node if result is empty
+ mode: "dimm", // Grayout unmatched nodes (pass "hide" to remove unmatched node instead)
+ },
+ nodeLoadChildren: function(ctx, source) {
+ var tree = ctx.tree;
+
+ return this._superApply(arguments).done(function() {
+ if (
+ tree.enableFilter &&
+ tree.lastFilterArgs &&
+ ctx.options.filter.autoApply
+ ) {
+ tree._applyFilterImpl.apply(tree, tree.lastFilterArgs);
+ }
+ });
+ },
+ nodeSetExpanded: function(ctx, flag, callOpts) {
+ var node = ctx.node;
+
+ delete node._filterAutoExpanded;
+ // Make sure counter badge is displayed again, when node is beeing collapsed
+ if (
+ !flag &&
+ ctx.options.filter.hideExpandedCounter &&
+ node.$subMatchBadge
+ ) {
+ node.$subMatchBadge.show();
+ }
+ return this._superApply(arguments);
+ },
+ nodeRenderStatus: function(ctx) {
+ // Set classes for current status
+ var res,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options.filter,
+ $title = $(node.span).find("span.fancytree-title"),
+ $span = $(node[tree.statusClassPropName]),
+ enhanceTitle = ctx.options.enhanceTitle,
+ escapeTitles = ctx.options.escapeTitles;
+
+ res = this._super(ctx);
+ // nothing to do, if node was not yet rendered
+ if (!$span.length || !tree.enableFilter) {
+ return res;
+ }
+ $span
+ .toggleClass("fancytree-match", !!node.match)
+ .toggleClass("fancytree-submatch", !!node.subMatchCount)
+ .toggleClass(
+ "fancytree-hide",
+ !(node.match || node.subMatchCount)
+ );
+ // Add/update counter badge
+ if (
+ opts.counter &&
+ node.subMatchCount &&
+ (!node.isExpanded() || !opts.hideExpandedCounter)
+ ) {
+ if (!node.$subMatchBadge) {
+ node.$subMatchBadge = $(
+ "").addClass(fcn.topLeft),
+ $topRightWrapper = $("
").addClass(fcn.topRight),
+ $bottomLeftWrapper = $("
").addClass(fcn.bottomLeft),
+ $bottomRightWrapper = $("
").addClass(fcn.bottomRight),
+ tableStyle = $table.attr("style"),
+ tableClass = $table.attr("class"),
+ $topLeftTable = $("
")
+ .attr("style", tableStyle)
+ .attr("class", tableClass),
+ $topRightTable = $("")
+ .attr("style", tableStyle)
+ .attr("class", tableClass),
+ $bottomLeftTable = $table,
+ $bottomRightTable = $("")
+ .attr("style", tableStyle)
+ .attr("class", tableClass),
+ $head = $table.find("thead"),
+ $colgroup = $table.find("colgroup"),
+ headRowCount = $head.find("tr").length;
+
+ this.$fixedWrapper = $tableWrapper;
+ $table.addClass(fcn.table);
+ $tableWrapper.addClass(fcn.wrapper);
+ $bottomRightTable.append($(""));
+
+ if ($colgroup.length) {
+ $colgroup.remove();
+ }
+
+ if (typeof fixedRowCount === "boolean") {
+ fixedRowCount = fixedRowCount ? headRowCount : 0;
+ } else {
+ fixedRowCount = Math.max(
+ 0,
+ Math.min(fixedRowCount, headRowCount)
+ );
+ }
+
+ if (fixedRowCount) {
+ $topLeftTable.append($head.clone(true));
+ $topRightTable.append($head.clone(true));
+ $head.remove();
+ }
+
+ $topLeftTable.find("tr").each(function(idx) {
+ $(this)
+ .find("th")
+ .slice(fixedColCount)
+ .remove();
+ });
+
+ $topRightTable.find("tr").each(function(idx) {
+ $(this)
+ .find("th")
+ .slice(0, fixedColCount)
+ .remove();
+ });
+
+ this.$fixedWrapper = $tableWrapper;
+
+ $tableWrapper.append(
+ $topLeftWrapper.append($topLeftTable),
+ $topRightWrapper.append($topRightTable),
+ $bottomLeftWrapper.append($bottomLeftTable),
+ $bottomRightWrapper.append($bottomRightTable)
+ );
+
+ $bottomRightTable.on("keydown", function(evt) {
+ var node = tree.focusNode,
+ ctx = tree._makeHookContext(node || tree, evt),
+ res = tree._callHook("nodeKeydown", ctx);
+ return res;
+ });
+
+ $bottomRightTable.on("click dblclick", "tr", function(evt) {
+ var $trLeft = $(this),
+ $trRight = $trLeft.data(fcn.counterpart),
+ node = $.ui.fancytree.getNode($trRight),
+ ctx = tree._makeHookContext(node, evt),
+ et = $.ui.fancytree.getEventTarget(evt),
+ prevPhase = tree.phase;
+
+ try {
+ tree.phase = "userEvent";
+ switch (evt.type) {
+ case "click":
+ ctx.targetType = et.type;
+ if (node.isPagingNode()) {
+ return (
+ tree._triggerNodeEvent(
+ "clickPaging",
+ ctx,
+ evt
+ ) === true
+ );
+ }
+ return tree._triggerNodeEvent("click", ctx, evt) ===
+ false
+ ? false
+ : tree._callHook("nodeClick", ctx);
+ case "dblclick":
+ ctx.targetType = et.type;
+ return tree._triggerNodeEvent(
+ "dblclick",
+ ctx,
+ evt
+ ) === false
+ ? false
+ : tree._callHook("nodeDblclick", ctx);
+ }
+ } finally {
+ tree.phase = prevPhase;
+ }
+ });
+
+ $tableWrapper
+ .on(
+ "mouseenter",
+ "." +
+ fcn.bottomRight +
+ " table tr, ." +
+ fcn.bottomLeft +
+ " table tr",
+ function(evt) {
+ var $tr = $(this),
+ $trOther = $tr.data(fcn.counterpart);
+ $tr.addClass(fcn.hover);
+ $trOther.addClass(fcn.hover);
+ }
+ )
+ .on(
+ "mouseleave",
+ "." +
+ fcn.bottomRight +
+ " table tr, ." +
+ fcn.bottomLeft +
+ " table tr",
+ function(evt) {
+ var $tr = $(this),
+ $trOther = $tr.data(fcn.counterpart);
+ $tr.removeClass(fcn.hover);
+ $trOther.removeClass(fcn.hover);
+ }
+ );
+
+ $bottomLeftWrapper.on("mousewheel DOMMouseScroll", function(event) {
+ var $this = $(this),
+ newScroll = $this.scrollTop(),
+ scrollUp =
+ event.originalEvent.wheelDelta > 0 ||
+ event.originalEvent.detail < 0;
+
+ newScroll += scrollUp
+ ? -options.scrollSpeed
+ : options.scrollSpeed;
+ $this.scrollTop(newScroll);
+ $bottomRightWrapper.scrollTop(newScroll);
+ event.preventDefault();
+ });
+
+ $bottomRightWrapper.scroll(function() {
+ var $this = $(this),
+ scrollLeft = $this.scrollLeft(),
+ scrollTop = $this.scrollTop();
+
+ $topLeftWrapper
+ .toggleClass(fcn.scrollBorderBottom, scrollTop > 0)
+ .toggleClass(fcn.scrollBorderRight, scrollLeft > 0);
+ $topRightWrapper
+ .toggleClass(fcn.scrollBorderBottom, scrollTop > 0)
+ .scrollLeft(scrollLeft);
+ $bottomLeftWrapper
+ .toggleClass(fcn.scrollBorderRight, scrollLeft > 0)
+ .scrollTop(scrollTop);
+ });
+
+ $.ui.fancytree.overrideMethod(
+ $.ui.fancytree._FancytreeNodeClass.prototype,
+ "scrollIntoView",
+ function(effects, options) {
+ var $prevContainer = tree.$container;
+ tree.$container = $bottomRightWrapper;
+ return this._super
+ .apply(this, arguments)
+ .always(function() {
+ tree.$container = $prevContainer;
+ });
+ }
+ );
+ return res;
+ },
+
+ treeLoad: function(ctx) {
+ var self = this,
+ res = this._superApply(arguments);
+
+ res.done(function() {
+ self.ext.fixed._adjustLayout.call(self);
+ if (self.options.fixed.resizable) {
+ self.ext.fixed._makeTableResizable();
+ }
+ });
+ return res;
+ },
+
+ _makeTableResizable: function() {
+ var $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames,
+ $topLeftWrapper = $wrapper.find("div." + fcn.topLeft),
+ $topRightWrapper = $wrapper.find("div." + fcn.topRight),
+ $bottomLeftWrapper = $wrapper.find("div." + fcn.bottomLeft),
+ $bottomRightWrapper = $wrapper.find("div." + fcn.bottomRight);
+
+ function _makeResizable($table) {
+ $table.resizable({
+ handles: "e",
+ resize: function(evt, ui) {
+ var width = Math.max($table.width(), ui.size.width);
+ $bottomLeftWrapper.css("width", width);
+ $topLeftWrapper.css("width", width);
+ $bottomRightWrapper.css("left", width);
+ $topRightWrapper.css("left", width);
+ },
+ stop: function() {
+ $table.css("width", "100%");
+ },
+ });
+ }
+
+ _makeResizable($topLeftWrapper.find("table"));
+ _makeResizable($bottomLeftWrapper.find("table"));
+ },
+
+ /* Called by nodeRender to sync node order with tag order.*/
+ // nodeFixOrder: function(ctx) {
+ // },
+
+ nodeLoadChildren: function(ctx, source) {
+ return this._superApply(arguments);
+ },
+
+ nodeRemoveChildMarkup: function(ctx) {
+ var node = ctx.node;
+
+ function _removeChild(elem) {
+ var i,
+ child,
+ children = elem.children;
+ if (children) {
+ for (i = 0; i < children.length; i++) {
+ child = children[i];
+ if (child.trRight) {
+ $(child.trRight).remove();
+ }
+ _removeChild(child);
+ }
+ }
+ }
+
+ _removeChild(node);
+ return this._superApply(arguments);
+ },
+
+ nodeRemoveMarkup: function(ctx) {
+ var node = ctx.node;
+
+ if (node.trRight) {
+ $(node.trRight).remove();
+ }
+ return this._superApply(arguments);
+ },
+
+ nodeSetActive: function(ctx, flag, callOpts) {
+ var node = ctx.node,
+ cn = this.options._classNames;
+
+ if (node.trRight) {
+ $(node.trRight)
+ .toggleClass(cn.active, flag)
+ .toggleClass(cn.focused, flag);
+ }
+ return this._superApply(arguments);
+ },
+
+ nodeKeydown: function(ctx) {
+ return this._superApply(arguments);
+ },
+
+ nodeSetFocus: function(ctx, flag) {
+ var node = ctx.node,
+ cn = this.options._classNames;
+
+ if (node.trRight) {
+ $(node.trRight).toggleClass(cn.focused, flag);
+ }
+ return this._superApply(arguments);
+ },
+
+ nodeRender: function(ctx, force, deep, collapsed, _recursive) {
+ var res = this._superApply(arguments),
+ node = ctx.node,
+ isRootNode = !node.parent;
+
+ if (!isRootNode) {
+ var $trLeft = $(node.tr),
+ fcn = this.options.fixed.classNames,
+ $trRight = $trLeft.data(fcn.counterpart);
+
+ if (!$trRight && $trLeft.length) {
+ var idx = $trLeft.index(),
+ fixedColCount = this.options.fixed.fixCols,
+ $blTableBody = $(
+ "div." + fcn.bottomLeft + " table tbody"
+ ),
+ $brTableBody = $(
+ "div." + fcn.bottomRight + " table tbody"
+ ),
+ $prevLeftNode = $blTableBody
+ .find("tr")
+ .eq(Math.max(idx + 1, 0)),
+ prevRightNode = $prevLeftNode.data(fcn.counterpart);
+
+ $trRight = $trLeft.clone(true);
+ var trRight = $trRight.get(0);
+
+ if (prevRightNode) {
+ $(prevRightNode).before($trRight);
+ } else {
+ $brTableBody.append($trRight);
+ }
+ $trRight.show();
+ trRight.ftnode = node;
+ node.trRight = trRight;
+
+ $trLeft
+ .find("td")
+ .slice(fixedColCount)
+ .remove();
+ $trRight
+ .find("td")
+ .slice(0, fixedColCount)
+ .remove();
+ $trLeft.data(fcn.counterpart, $trRight);
+ $trRight.data(fcn.counterpart, $trLeft);
+ }
+ }
+
+ return res;
+ },
+
+ nodeRenderTitle: function(ctx, title) {
+ return this._superApply(arguments);
+ },
+
+ nodeRenderStatus: function(ctx) {
+ var res = this._superApply(arguments),
+ node = ctx.node;
+
+ if (node.trRight) {
+ var $trRight = $(node.trRight),
+ $trLeft = $(node.tr),
+ fcn = this.options.fixed.classNames,
+ hovering = $trRight.hasClass(fcn.hover),
+ trClasses = $trLeft.attr("class");
+
+ $trRight.attr("class", trClasses);
+ if (hovering) {
+ $trRight.addClass(fcn.hover);
+ $trLeft.addClass(fcn.hover);
+ }
+ }
+ return res;
+ },
+
+ nodeSetExpanded: function(ctx, flag, callOpts) {
+ var res,
+ self = this,
+ node = ctx.node,
+ $leftTr = $(node.tr),
+ fcn = this.options.fixed.classNames,
+ cn = this.options._classNames,
+ $rightTr = $leftTr.data(fcn.counterpart);
+
+ flag = typeof flag === "undefined" ? true : flag;
+
+ if (!$rightTr) {
+ return this._superApply(arguments);
+ }
+ $rightTr.toggleClass(cn.expanded, !!flag);
+ if (flag && !node.isExpanded()) {
+ res = this._superApply(arguments);
+ res.done(function() {
+ node.visit(function(child) {
+ var $trLeft = $(child.tr),
+ $trRight = $trLeft.data(fcn.counterpart);
+
+ self.ext.fixed._adjustRowHeight($trLeft, $trRight);
+ if (!child.expanded) {
+ return "skip";
+ }
+ });
+
+ self.ext.fixed._adjustColWidths();
+ self.ext.fixed._adjustWrapperLayout();
+ });
+ } else if (!flag && node.isExpanded()) {
+ node.visit(function(child) {
+ var $trLeft = $(child.tr),
+ $trRight = $trLeft.data(fcn.counterpart);
+ if ($trRight) {
+ if (!child.expanded) {
+ return "skip";
+ }
+ }
+ });
+
+ self.ext.fixed._adjustColWidths();
+ self.ext.fixed._adjustWrapperLayout();
+ res = this._superApply(arguments);
+ } else {
+ res = this._superApply(arguments);
+ }
+ return res;
+ },
+
+ nodeSetStatus: function(ctx, status, message, details) {
+ return this._superApply(arguments);
+ },
+
+ treeClear: function(ctx) {
+ var tree = ctx.tree,
+ $table = tree.widget.element,
+ $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames;
+
+ $table
+ .find("tr, td, th, thead")
+ .removeClass(fcn.hidden)
+ .css({
+ "min-width": "auto",
+ height: "auto",
+ });
+ $wrapper.empty().append($table);
+ return this._superApply(arguments);
+ },
+
+ treeRegisterNode: function(ctx, add, node) {
+ return this._superApply(arguments);
+ },
+
+ treeDestroy: function(ctx) {
+ var tree = ctx.tree,
+ $table = tree.widget.element,
+ $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames;
+
+ $table
+ .find("tr, td, th, thead")
+ .removeClass(fcn.hidden)
+ .css({
+ "min-width": "auto",
+ height: "auto",
+ });
+ $wrapper.empty().append($table);
+ return this._superApply(arguments);
+ },
+
+ _adjustColWidths: function() {
+ if (this.options.fixed.adjustColWidths) {
+ this.options.fixed.adjustColWidths.call(this);
+ return;
+ }
+
+ var $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames,
+ $tlWrapper = $wrapper.find("div." + fcn.topLeft),
+ $blWrapper = $wrapper.find("div." + fcn.bottomLeft),
+ $trWrapper = $wrapper.find("div." + fcn.topRight),
+ $brWrapper = $wrapper.find("div." + fcn.bottomRight);
+
+ function _adjust($topWrapper, $bottomWrapper) {
+ var $trTop = $topWrapper.find("thead tr").first(),
+ $trBottom = $bottomWrapper.find("tbody tr").first();
+
+ $trTop.find("th").each(function(idx) {
+ var $thTop = $(this),
+ $tdBottom = $trBottom.find("td").eq(idx),
+ thTopWidth = $thTop.width(),
+ thTopOuterWidth = $thTop.outerWidth(),
+ tdBottomWidth = $tdBottom.width(),
+ tdBottomOuterWidth = $tdBottom.outerWidth(),
+ newWidth = Math.max(
+ thTopOuterWidth,
+ tdBottomOuterWidth
+ );
+
+ $thTop.css(
+ "min-width",
+ newWidth - (thTopOuterWidth - thTopWidth)
+ );
+ $tdBottom.css(
+ "min-width",
+ newWidth - (tdBottomOuterWidth - tdBottomWidth)
+ );
+ });
+ }
+
+ _adjust($tlWrapper, $blWrapper);
+ _adjust($trWrapper, $brWrapper);
+ },
+
+ _adjustRowHeight: function($tr1, $tr2) {
+ var fcn = this.options.fixed.classNames;
+ if (!$tr2) {
+ $tr2 = $tr1.data(fcn.counterpart);
+ }
+ $tr1.css("height", "auto");
+ $tr2.css("height", "auto");
+ var row1Height = $tr1.outerHeight(),
+ row2Height = $tr2.outerHeight(),
+ newHeight = Math.max(row1Height, row2Height);
+ $tr1.css("height", newHeight + 1);
+ $tr2.css("height", newHeight + 1);
+ },
+
+ _adjustWrapperLayout: function() {
+ var $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames,
+ $topLeftWrapper = $wrapper.find("div." + fcn.topLeft),
+ $topRightWrapper = $wrapper.find("div." + fcn.topRight),
+ $bottomLeftWrapper = $wrapper.find("div." + fcn.bottomLeft),
+ $bottomRightWrapper = $wrapper.find("div." + fcn.bottomRight),
+ $topLeftTable = $topLeftWrapper.find("table"),
+ $topRightTable = $topRightWrapper.find("table"),
+ // $bottomLeftTable = $bottomLeftWrapper.find("table"),
+ wrapperWidth = $wrapper.width(),
+ wrapperHeight = $wrapper.height(),
+ fixedWidth = Math.min(wrapperWidth, $topLeftTable.width()),
+ fixedHeight = Math.min(
+ wrapperHeight,
+ Math.max($topLeftTable.height(), $topRightTable.height())
+ );
+ // vScrollbar = $bottomRightWrapper.get(0).scrollHeight > (wrapperHeight - fixedHeight),
+ // hScrollbar = $bottomRightWrapper.get(0).scrollWidth > (wrapperWidth - fixedWidth);
+
+ $topLeftWrapper.css({
+ width: fixedWidth,
+ height: fixedHeight,
+ });
+ $topRightWrapper.css({
+ // width: wrapperWidth - fixedWidth - (vScrollbar ? 17 : 0),
+ // width: "calc(100% - " + (fixedWidth + (vScrollbar ? 17 : 0)) + "px)",
+ width: "calc(100% - " + (fixedWidth + 17) + "px)",
+ height: fixedHeight,
+ left: fixedWidth,
+ });
+ $bottomLeftWrapper.css({
+ width: fixedWidth,
+ // height: vScrollbar ? wrapperHeight - fixedHeight - (hScrollbar ? 17 : 0) : "auto",
+ // height: vScrollbar ? ("calc(100% - " + (fixedHeight + (hScrollbar ? 17 : 0)) + "px)") : "auto",
+ // height: vScrollbar ? ("calc(100% - " + (fixedHeight + 17) + "px)") : "auto",
+ height: "calc(100% - " + (fixedHeight + 17) + "px)",
+ top: fixedHeight,
+ });
+ $bottomRightWrapper.css({
+ // width: wrapperWidth - fixedWidth,
+ // height: vScrollbar ? wrapperHeight - fixedHeight : "auto",
+ width: "calc(100% - " + fixedWidth + "px)",
+ // height: vScrollbar ? ("calc(100% - " + fixedHeight + "px)") : "auto",
+ height: "calc(100% - " + fixedHeight + "px)",
+ top: fixedHeight,
+ left: fixedWidth,
+ });
+ },
+
+ _adjustLayout: function() {
+ var self = this,
+ $wrapper = this.$fixedWrapper,
+ fcn = this.options.fixed.classNames,
+ $topLeftWrapper = $wrapper.find("div." + fcn.topLeft),
+ $topRightWrapper = $wrapper.find("div." + fcn.topRight),
+ $bottomLeftWrapper = $wrapper.find("div." + fcn.bottomLeft);
+ // $bottomRightWrapper = $wrapper.find("div." + fcn.bottomRight)
+
+ $topLeftWrapper.find("table tr").each(function(idx) {
+ var $trRight = $topRightWrapper.find("tr").eq(idx);
+ self.ext.fixed._adjustRowHeight($(this), $trRight);
+ });
+
+ $bottomLeftWrapper
+ .find("table tbody")
+ .find("tr")
+ .each(function(idx) {
+ // var $trRight = $bottomRightWrapper.find("tbody").find("tr").eq(idx);
+ self.ext.fixed._adjustRowHeight($(this));
+ });
+
+ self.ext.fixed._adjustColWidths.call(this);
+ self.ext.fixed._adjustWrapperLayout.call(this);
+ },
+
+ // treeSetFocus: function(ctx, flag) {
+ //// alert("treeSetFocus" + ctx.tree.$container);
+ // ctx.tree.$container.focus();
+ // $.ui.fancytree.focusTree = ctx.tree;
+ // }
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.glyph.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.glyph.js
new file mode 100644
index 0000000..eb153b6
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.glyph.js
@@ -0,0 +1,336 @@
+/*!
+ * jquery.fancytree.glyph.js
+ *
+ * Use glyph-fonts, ligature-fonts, or SVG icons instead of icon sprites.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /******************************************************************************
+ * Private functions and variables
+ */
+
+ var FT = $.ui.fancytree,
+ PRESETS = {
+ awesome3: {
+ // Outdated!
+ _addClass: "",
+ checkbox: "icon-check-empty",
+ checkboxSelected: "icon-check",
+ checkboxUnknown: "icon-check icon-muted",
+ dragHelper: "icon-caret-right",
+ dropMarker: "icon-caret-right",
+ error: "icon-exclamation-sign",
+ expanderClosed: "icon-caret-right",
+ expanderLazy: "icon-angle-right",
+ expanderOpen: "icon-caret-down",
+ loading: "icon-refresh icon-spin",
+ nodata: "icon-meh",
+ noExpander: "",
+ radio: "icon-circle-blank",
+ radioSelected: "icon-circle",
+ // radioUnknown: "icon-circle icon-muted",
+ // Default node icons.
+ // (Use tree.options.icon callback to define custom icons based on node data)
+ doc: "icon-file-alt",
+ docOpen: "icon-file-alt",
+ folder: "icon-folder-close-alt",
+ folderOpen: "icon-folder-open-alt",
+ },
+ awesome4: {
+ _addClass: "fa",
+ checkbox: "fa-square-o",
+ checkboxSelected: "fa-check-square-o",
+ checkboxUnknown: "fa-square fancytree-helper-indeterminate-cb",
+ dragHelper: "fa-arrow-right",
+ dropMarker: "fa-long-arrow-right",
+ error: "fa-warning",
+ expanderClosed: "fa-caret-right",
+ expanderLazy: "fa-angle-right",
+ expanderOpen: "fa-caret-down",
+ // We may prevent wobbling rotations on FF by creating a separate sub element:
+ loading: { html: "", {
+ class: "fancytree-scrollbar",
+ css: {
+ border: "1px solid gray",
+ position: "absolute",
+ top: position.top,
+ left: position.left + $table.width(),
+ width: sbWidth,
+ height: $table.find("tbody").height(),
+ },
+ });
+
+ $table
+ .css({
+ "margin-right": sbWidth,
+ })
+ .after($sb);
+
+ return $sb;
+ }
+
+ /*
+ * [ext-grid] Invalidate renumber status, i.e. trigger renumber next time.
+ *
+ * @alias Fancytree#_renumberReset
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype._renumberReset = function() {
+ // this.debug("_renumberReset()");
+ this.visibleNodeList = null;
+ };
+
+ /*
+ * [ext-grid] Adjust the start value if the content would be outside otherwise.
+ *
+ * @alias Fancytree#_fixStart
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype._fixStart = function(
+ start,
+ apply
+ ) {
+ var vp = this.viewport,
+ nodeList = this.visibleNodeList;
+
+ start = start == null ? vp.start : start;
+ // this.debug("_fixStart(" + start + ", " + !!apply + ")");
+ var orgStart = start;
+ // Don't scroll down below bottom node
+ if (nodeList) {
+ start = Math.min(start, this.visibleNodeList.length - vp.count);
+ start = Math.max(start, 0, start);
+ if (start !== orgStart) {
+ this.debug("Adjust start " + orgStart + " => " + start);
+ if (apply) {
+ vp.start = start;
+ }
+ }
+ }
+ return start;
+ };
+
+ /*
+ * [ext-grid] ...
+ *
+ * @alias Fancytree#_shiftViewport
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype._shiftViewport = function(
+ mode,
+ ofs
+ ) {
+ this.debug("_shiftViewport", mode, ofs);
+ switch (mode) {
+ case "vscroll":
+ if (ofs) {
+ this.setViewport({
+ start: this.viewport.start + (ofs > 0 ? 1 : -1),
+ });
+ }
+ break;
+
+ default:
+ throw Error("Invalid mode: " + mode);
+ }
+ };
+
+ /**
+ * [ext-grid] Return true if viewport cannot be scrolled down any further.
+ *
+ * @alias Fancytree#isViewportBottom
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.isViewportBottom = function() {
+ return (
+ this.viewport.start + this.viewport.count >=
+ this.visibleNodeList.length
+ );
+ };
+
+ /**
+ * [ext-grid] Define a subset of rows/columns to display and redraw.
+ *
+ * @param {object | boolean} options viewport boundaries and status.
+ *
+ * @alias Fancytree#setViewport
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.setViewport = function(opts) {
+ if (typeof opts === "boolean") {
+ this.debug("setViewport( " + opts + ")");
+ return this.setViewport({ enabled: opts });
+ }
+ opts = opts || {};
+ var i,
+ count,
+ start,
+ newRow,
+ redrawReason = "",
+ vp = this.viewport,
+ diffVp = { start: 0, count: 0, enabled: null, force: null },
+ newVp = $.extend({}, vp),
+ trList = this.tbody.children,
+ trCount = trList.length;
+
+ // Sanitize viewport settings and check if we need to redraw
+ this.debug("setViewport(" + opts.start + ", +" + opts.count + ")");
+ if (opts.force) {
+ redrawReason += "force";
+ diffVp.force = true;
+ }
+
+ opts.enabled = opts.enabled !== false; // default to true
+ if (vp.enabled !== opts.enabled) {
+ redrawReason += "enable";
+ newVp.enabled = diffVp.enabled = opts.enabled;
+ }
+
+ start = opts.start == null ? vp.start : Math.max(0, +opts.start);
+ // Adjust start value to assure the current content is inside vp
+ start = this._fixStart(start, false);
+
+ if (vp.start !== +start) {
+ redrawReason += "start";
+ newVp.start = start;
+ diffVp.start = start - vp.start;
+ }
+
+ count = opts.count == null ? vp.count : Math.max(1, +opts.count);
+ if (vp.count !== +count) {
+ redrawReason += "count";
+ newVp.count = count;
+ diffVp.count = count - vp.count;
+ }
+ // if (vp.left !== +opts.left) {
+ // diffVp.left = left - vp.left;
+ // newVp.left = opts.left;
+ // redrawReason += "left";
+ // }
+ // if (vp.right !== +opts.right) {
+ // diffVp.right = right - vp.right;
+ // newVp.right = opts.right;
+ // redrawReason += "right";
+ // }
+
+ if (!redrawReason) {
+ return false;
+ }
+ // Let user cancel or modify the update
+ var info = {
+ next: newVp,
+ diff: diffVp,
+ reason: redrawReason,
+ scrollOnly: redrawReason === "start",
+ };
+ if (
+ !opts.noEvents &&
+ this._triggerTreeEvent("beforeUpdateViewport", null, info) === false
+ ) {
+ return false;
+ }
+ info.prev = $.extend({}, vp);
+ delete info.next;
+ // vp.enabled = newVp.enabled;
+ vp.start = newVp.start;
+ vp.count = newVp.count;
+
+ // Make sure we have the correct count of TRs
+ var prevPhase = this.isVpUpdating;
+
+ if (trCount > count) {
+ for (i = 0; i < trCount - count; i++) {
+ delete this.tbody.lastChild.ftnode;
+ this.tbody.removeChild(this.tbody.lastChild);
+ }
+ } else if (trCount < count) {
+ for (i = 0; i < count - trCount; i++) {
+ newRow = this.rowFragment.firstChild.cloneNode(true);
+ this.tbody.appendChild(newRow);
+ }
+ }
+ trCount = trList.length;
+
+ // Update visible node cache if needed
+ var force = opts.force;
+ this.redrawViewport(force);
+
+ if (!opts.noEvents) {
+ this._triggerTreeEvent("updateViewport", null, info);
+ }
+
+ this.isVpUpdating = prevPhase;
+ return true;
+ };
+
+ /**
+ * [ext-grid] Calculate the viewport count from current scroll wrapper height.
+ *
+ * @alias Fancytree#adjustViewportSize
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.adjustViewportSize = function() {
+ _assert(
+ this.scrollWrapper,
+ "No parent div.fancytree-grid-container found."
+ );
+ if (this.isVpUpdating) {
+ this.debug("Ignoring adjustViewportSize() during VP update.");
+ return;
+ }
+ // Calculate how many rows fit into current container height
+ var $table = this.$container,
+ wrapper = this.scrollWrapper,
+ trHeight =
+ $table
+ .find(">tbody>tr")
+ .first()
+ .height() || 0,
+ tableHeight = $table.height(),
+ headHeight = tableHeight - this.viewport.count * trHeight,
+ wrapperHeight = wrapper.offsetHeight,
+ free = wrapperHeight - headHeight,
+ newCount = trHeight ? Math.floor(free / trHeight) : 0;
+
+ // console.info(
+ // "set container height",
+ // $(this)
+ // .parent(".fancytree-grid-container")
+ // .height()
+ // );
+
+ this.setViewport({ count: newCount });
+ // if (SCROLL_MODE === "scroll") {
+ // // Add bottom margin to the table, to make sure the wrapper becomes
+ // // scrollable
+ // var mb = wrapperHeight - $table.height() - 2.0 * EPS;
+ // this.debug("margin-bottom=" + mb);
+ // $table.css("margin-bottom", mb);
+ // }
+ };
+
+ /*
+ * [ext-grid] Calculate the scroll container dimension from the current tree table.
+ *
+ * @alias Fancytree#initViewportWrapper
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype._initViewportWrapper = function() {
+ var // wrapper = this.scrollWrapper,
+ // $wrapper = $(wrapper),
+ tree = this;
+
+ // if (SCROLL_MODE === "scroll") {
+ // $wrapper.on("scroll", function(e) {
+ // var viewport = tree.viewport,
+ // curTop = wrapper.scrollTop,
+ // homeTop = viewport.start === 0 ? 0 : EPS,
+ // dy = viewport.start === 0 ? 1 : curTop - EPS; //homeTop;
+
+ // tree.debug(
+ // "Got 'scroll' event: scrollTop=" +
+ // curTop +
+ // ", homeTop=" +
+ // homeTop +
+ // ", start=" +
+ // viewport.start +
+ // ", dy=" +
+ // dy
+ // );
+ // if (tree.isVpUpdating) {
+ // tree.debug("Ignoring scroll during VP update.");
+ // return;
+ // } else if (curTop === homeTop) {
+ // tree.debug("Ignoring scroll to neutral " + homeTop + ".");
+ // return;
+ // }
+ // tree._shiftViewport("vscroll", dy);
+ // homeTop = viewport.start === 0 ? 0 : EPS;
+ // setTimeout(function() {
+ // tree.debug(
+ // "scrollTop(" +
+ // wrapper.scrollTop +
+ // " -> " +
+ // homeTop +
+ // ")..."
+ // );
+ // wrapper.scrollTop = homeTop;
+ // }, 0);
+ // });
+ // }
+ if (SCROLL_MODE === "wheel") {
+ this.$container.on("wheel", function(e) {
+ var orgEvent = e.originalEvent,
+ viewport = tree.viewport,
+ dy = orgEvent.deltaY; // * orgEvent.wheelDeltaY;
+
+ if (!dy || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) {
+ return true;
+ }
+ if (dy < 0 && viewport.start === 0) {
+ return true;
+ }
+ if (dy > 0 && tree.isViewportBottom()) {
+ return true;
+ }
+ tree.debug(
+ "Got 'wheel' event: dy=" +
+ dy +
+ ", mode=" +
+ orgEvent.deltaMode
+ );
+ tree._shiftViewport("vscroll", dy);
+ return false;
+ });
+ }
+ };
+
+ /*
+ * [ext-grid] Renumber and collect all visible rows.
+ *
+ * @param {bool} [force=false]
+ * @param {FancytreeNode | int} [startIdx=0]
+ * @alias Fancytree#_renumberVisibleNodes
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype._renumberVisibleNodes = function(
+ force,
+ startIdx
+ ) {
+ if (
+ (!this.options.viewport.enabled || this.visibleNodeList != null) &&
+ force !== true
+ ) {
+ // this.debug("_renumberVisibleNodes() ignored.");
+ return false;
+ }
+ this.debugTime("_renumberVisibleNodes()");
+ var i = 0,
+ prevLength = this.visibleNodeList ? this.visibleNodeList.length : 0,
+ visibleNodeList = (this.visibleNodeList = []);
+
+ // Reset previous data
+ this.visit(function(node) {
+ node._rowIdx = null;
+ // node.span = null;
+ // if (node.tr) {
+ // delete node.tr.ftnode;
+ // node.tr = null;
+ // }
+ });
+ // Iterate over all *visible* nodes
+ this.visitRows(function(node) {
+ node._rowIdx = i++;
+ visibleNodeList.push(node);
+ });
+ this.debugTimeEnd("_renumberVisibleNodes()");
+ if (i !== prevLength) {
+ this._triggerTreeEvent("updateViewport", null, {
+ reason: "renumber",
+ diff: { start: 0, count: 0, enabled: null, force: null },
+ next: $.extend({}, this.viewport),
+ // visibleCount: prevLength,
+ // cur: i,
+ });
+ }
+ };
+
+ /**
+ * [ext-grid] Render all visible nodes into the viweport.
+ *
+ * @param {bool} [force=false]
+ * @alias Fancytree#redrawViewport
+ * @requires jquery.fancytree.grid.js
+ */
+ $.ui.fancytree._FancytreeClass.prototype.redrawViewport = function(force) {
+ if (this._enableUpdate === false) {
+ // tree.debug("no render", tree._enableUpdate);
+ return;
+ }
+ this.debugTime("redrawViewport()");
+ this._renumberVisibleNodes(force);
+ // Adjust vp.start value to assure the current content is inside:
+ this._fixStart(null, true);
+
+ var i = 0,
+ vp = this.viewport,
+ visibleNodeList = this.visibleNodeList,
+ start = vp.start,
+ bottom = start + vp.count,
+ tr,
+ _renderCount = 0,
+ trIdx = 0,
+ trList = this.tbody.children,
+ prevPhase = this.isVpUpdating;
+
+ // Reset previous data
+ this.visit(function(node) {
+ // node.debug("redrawViewport(): _rowIdx=" + node._rowIdx);
+ node.span = null;
+ if (node.tr) {
+ delete node.tr.ftnode;
+ node.tr = null;
+ }
+ });
+
+ // Redraw the whole tree, erasing all node markup before and after
+ // the viewport
+
+ for (i = start; i < bottom; i++) {
+ var node = visibleNodeList[i];
+
+ tr = trList[trIdx];
+
+ if (!node) {
+ // TODO: make trailing empty rows configurable (custom template or remove TRs)
+ var newRow = this.rowFragment.firstChild.cloneNode(true);
+ this.tbody.replaceChild(newRow, tr);
+ trIdx++;
+ continue;
+ }
+ if (tr !== node.tr) {
+ node.tr = tr;
+ node.render();
+ _renderCount++;
+
+ // TODO:
+ // Implement scrolling by re-using existing markup
+ // e.g. shifting TRs or TR child elements instead of
+ // re-creating all the time
+ }
+ trIdx++;
+ }
+ this.isVpUpdating = prevPhase;
+ this.debugTimeEnd("redrawViewport()");
+ };
+
+ $.ui.fancytree.registerExtension({
+ name: "grid",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {
+ checkboxColumnIdx: null, // render the checkboxes into the this column index (default: nodeColumnIdx)
+ indentation: 16, // indent every node level by 16px
+ mergeStatusColumns: true, // display 'nodata', 'loading', 'error' centered in a single, merged TR
+ nodeColumnIdx: 0, // render node expander, icon, and title to this column (default: #0)
+ },
+ // Overide virtual methods for this extension.
+ // `this` : is this extension object
+ // `this._super`: the virtual function that was overriden (member of prev. extension or Fancytree)
+ treeInit: function(ctx) {
+ var i,
+ columnCount,
+ n,
+ $row,
+ $tbody,
+ tree = ctx.tree,
+ opts = ctx.options,
+ tableOpts = opts.table,
+ $table = tree.widget.element,
+ $scrollWrapper = $table.parent(".fancytree-grid-container");
+
+ if ($.inArray("table", opts.extensions) >= 0) {
+ $.error("ext-grid and ext-table are mutually exclusive.");
+ }
+ if (opts.renderStatusColumns === true) {
+ opts.renderStatusColumns = opts.renderColumns;
+ }
+ // Note: we also re-use CSS rules from ext-table
+ $table.addClass(
+ "fancytree-container fancytree-ext-grid fancytree-ext-table"
+ );
+ $tbody = $table.find(">tbody");
+ if (!$tbody.length) {
+ // TODO: not sure if we can rely on browsers to insert missing
before s:
+ if ($table.find(">tr").length) {
+ $.error(
+ "Expected table > tbody > tr. If you see this, please open an issue."
+ );
+ }
+ $tbody = $(" ").appendTo($table);
+ }
+
+ tree.tbody = $tbody[0];
+
+ // Prepare row templates:
+ // Determine column count from table header if any
+ columnCount = $("thead >tr", $table)
+ .last()
+ .find(">th").length;
+ // Read TR templates from tbody if any
+ $row = $tbody.children("tr").first();
+ if ($row.length) {
+ n = $row.children("td").length;
+ if (columnCount && n !== columnCount) {
+ tree.warn(
+ "Column count mismatch between thead (" +
+ columnCount +
+ ") and tbody (" +
+ n +
+ "): using tbody."
+ );
+ columnCount = n;
+ }
+ $row = $row.clone();
+ } else {
+ // Only thead is defined: create default row markup
+ _assert(
+ columnCount >= 1,
+ "Need either or with elements to determine column count."
+ );
+ $row = $(" elements
+ tree.statusClassPropName = "tr";
+ tree.ariaPropName = "tr";
+ this.nodeContainerAttrName = "tr";
+
+ // #489: make sure $container is set to , even if ext-dnd is listed before ext-grid
+ tree.$container = $table;
+ if ($scrollWrapper.length) {
+ tree.scrollWrapper = $scrollWrapper[0];
+ this._initViewportWrapper();
+ } else {
+ tree.scrollWrapper = null;
+ }
+
+ // Scrolling is implemented completely differently here
+ $.ui.fancytree.overrideMethod(
+ $.ui.fancytree._FancytreeNodeClass.prototype,
+ "scrollIntoView",
+ function(effects, options) {
+ var node = this,
+ tree = node.tree,
+ topNode = options && options.topNode,
+ vp = tree.viewport,
+ start = vp ? vp.start : null;
+
+ if (!tree.viewport) {
+ return node._super.apply(this, arguments);
+ }
+ if (node._rowIdx < vp.start) {
+ start = node._rowIdx;
+ } else if (node._rowIdx >= vp.start + vp.count) {
+ start = node._rowIdx - vp.count + 1;
+ }
+ if (topNode && topNode._rowIdx < start) {
+ start = topNode._rowIdx;
+ }
+ tree.setViewport({ start: start });
+ // Return a resolved promise
+ return $.Deferred(function() {
+ this.resolveWith(node);
+ }).promise();
+ }
+ );
+
+ tree.visibleNodeList = null; // Set by _renumberVisibleNodes()
+ tree.viewport = {
+ enabled: true,
+ start: 0,
+ count: 10,
+ left: 0,
+ right: 0,
+ };
+ this.setViewport(
+ $.extend(
+ {
+ // enabled: true,
+ autoSize: true,
+ start: 0,
+ count: 10,
+ left: 0,
+ right: 0,
+ keepEmptyRows: true,
+ noEvents: true,
+ },
+ opts.viewport
+ )
+ );
+ // tree.$scrollbar = _addScrollbar($table);
+
+ this._superApply(arguments);
+
+ // standard Fancytree created a root UL
+ $(tree.rootNode.ul).remove();
+ tree.rootNode.ul = null;
+
+ // Add container to the TAB chain
+ // #577: Allow to set tabindex to "0", "-1" and ""
+ this.$container.attr("tabindex", opts.tabindex);
+ // this.$container.attr("tabindex", opts.tabbable ? "0" : "-1");
+ if (opts.aria) {
+ tree.$container
+ .attr("role", "treegrid")
+ .attr("aria-readonly", true);
+ }
+ },
+ nodeKeydown: function(ctx) {
+ var nextNode = null,
+ nextIdx = null,
+ tree = ctx.tree,
+ node = ctx.node,
+ nodeList = tree.visibleNodeList,
+ // treeOpts = ctx.options,
+ viewport = tree.viewport,
+ event = ctx.originalEvent,
+ eventString = FT.eventToString(event);
+
+ tree.debug("nodeKeydown(" + eventString + ")");
+
+ switch (eventString) {
+ case "home":
+ case "meta+up":
+ nextIdx = 0;
+ break;
+ case "end":
+ case "meta+down":
+ nextIdx = nodeList.length - 1;
+ break;
+ case "pageup":
+ nextIdx = node._rowIdx - viewport.count;
+ break;
+ case "pagedown":
+ nextIdx = node._rowIdx + viewport.count;
+ break;
+ }
+ if (nextIdx != null) {
+ nextIdx = Math.min(Math.max(0, nextIdx), nodeList.length - 1);
+ nextNode = nodeList[nextIdx];
+ nextNode.makeVisible();
+ nextNode.setActive();
+ return false;
+ }
+ return this._superApply(arguments);
+ },
+ nodeRemoveChildMarkup: function(ctx) {
+ var node = ctx.node;
+
+ node.visit(function(n) {
+ if (n.tr) {
+ delete n.tr.ftnode;
+ n.tr = null;
+ n.span = null;
+ }
+ });
+ },
+ nodeRemoveMarkup: function(ctx) {
+ var node = ctx.node;
+
+ if (node.tr) {
+ delete node.tr.ftnode;
+ node.tr = null;
+ node.span = null;
+ }
+ this.nodeRemoveChildMarkup(ctx);
+ },
+ /* Override standard render. */
+ nodeRender: function(ctx, force, deep, collapsed, _recursive) {
+ var children,
+ i,
+ l,
+ outsideViewport,
+ subCtx,
+ tree = ctx.tree,
+ node = ctx.node;
+
+ if (tree._enableUpdate === false) {
+ node.debug("nodeRender(): _enableUpdate: false");
+ return;
+ }
+ var opts = ctx.options,
+ viewport = tree.viewport.enabled ? tree.viewport : null,
+ start = viewport && viewport.start > 0 ? +viewport.start : 0,
+ bottom = viewport ? start + viewport.count - 1 : 0,
+ isRootNode = !node.parent;
+
+ _assert(viewport);
+
+ // node.debug("nodeRender(): " + node + ", isRoot=" + isRootNode, "tr=" + node.tr, "hcp=" + ctx.hasCollapsedParents, "parent.tr=" + (node.parent && node.parent.tr));
+ if (!_recursive) {
+ // node.debug("nodeRender(): start top node");
+ if (isRootNode && viewport) {
+ node.debug("nodeRender(): redrawViewport() instead");
+ return ctx.tree.redrawViewport();
+ }
+ ctx.hasCollapsedParents = node.parent && !node.parent.expanded;
+ // Make sure visible row indices are up-to-date
+ if (viewport) {
+ tree._renumberVisibleNodes();
+ }
+ }
+
+ if (!isRootNode) {
+ outsideViewport =
+ viewport &&
+ (node._rowIdx < start ||
+ node._rowIdx >= start + viewport.count);
+
+ // node.debug(
+ // "nodeRender(): idx=" +
+ // node._rowIdx +
+ // ", outside=" +
+ // outsideViewport +
+ // ", TR count=" +
+ // tree.tbody.rows.length
+ // );
+ if (outsideViewport) {
+ // node.debug("nodeRender(): outsideViewport: ignored");
+ return;
+ }
+ if (!node.tr) {
+ if (node._rowIdx == null) {
+ // node.warn("nodeRender(): ignoring hidden");
+ return;
+ }
+ node.debug("nodeRender(): creating new TR.");
+ node.tr = tree.tbody.rows[node._rowIdx - start];
+ }
+ // _assert(
+ // node.tr,
+ // "nodeRender() called for node.tr == null: " + node
+ // );
+ node.tr.ftnode = node;
+
+ if (node.key && opts.generateIds) {
+ node.tr.id = opts.idPrefix + node.key;
+ }
+ node.span = $("span.fancytree-node", node.tr).get(0);
+
+ // Set icon, link, and title (normally this is only required on initial render)
+ // var ctx = this._makeHookContext(node);
+ this.nodeRenderTitle(ctx); // triggers renderColumns()
+
+ // Allow tweaking, binding, after node was created for the first time
+ if (opts.createNode) {
+ opts.createNode.call(this, { type: "createNode" }, ctx);
+ }
+ }
+ // Allow tweaking after node state was rendered
+ if (opts.renderNode) {
+ opts.renderNode.call(tree, { type: "renderNode" }, ctx);
+ }
+ // Visit child nodes
+ // Add child markup
+ children = node.children;
+ _assert(!deep, "deep is not supported");
+
+ if (children && (isRootNode || deep || node.expanded)) {
+ for (i = 0, l = children.length; i < l; i++) {
+ var child = children[i];
+
+ if (viewport && child._rowIdx > bottom) {
+ children[i].debug("BREAK render children loop");
+ return false;
+ }
+ subCtx = $.extend({}, ctx, { node: child });
+ subCtx.hasCollapsedParents =
+ subCtx.hasCollapsedParents || !node.expanded;
+ this.nodeRender(subCtx, force, deep, collapsed, true);
+ }
+ }
+ },
+ nodeRenderTitle: function(ctx, title) {
+ var $cb,
+ res,
+ tree = ctx.tree,
+ node = ctx.node,
+ opts = ctx.options,
+ isStatusNode = node.isStatusNode();
+
+ res = this._super(ctx, title);
+
+ if (node.isRootNode()) {
+ return res;
+ }
+ // Move checkbox to custom column
+ if (
+ opts.checkbox &&
+ !isStatusNode &&
+ opts.table.checkboxColumnIdx != null
+ ) {
+ $cb = $("span.fancytree-checkbox", node.span); //.detach();
+ $(node.tr)
+ .find("td")
+ .eq(+opts.table.checkboxColumnIdx)
+ .html($cb);
+ }
+ // Update element classes according to node state
+ this.nodeRenderStatus(ctx);
+
+ if (isStatusNode) {
+ if (opts.renderStatusColumns) {
+ // Let user code write column content
+ opts.renderStatusColumns.call(
+ tree,
+ { type: "renderStatusColumns" },
+ ctx
+ );
+ } else if (opts.grid.mergeStatusColumns && node.isTopLevel()) {
+ node.warn("mergeStatusColumns is not yet implemented.");
+ // This approach would not work, since the roe may be re-used:
+ // $(node.tr)
+ // .find(">td")
+ // .eq(0)
+ // .prop("colspan", tree.columnCount)
+ // .text(node.title)
+ // .addClass("fancytree-status-merged")
+ // .nextAll()
+ // .remove();
+ } // else: default rendering for status node: leave other cells empty
+ } else if (opts.renderColumns) {
+ opts.renderColumns.call(tree, { type: "renderColumns" }, ctx);
+ }
+ return res;
+ },
+ nodeRenderStatus: function(ctx) {
+ var indent,
+ node = ctx.node,
+ opts = ctx.options;
+
+ this._super(ctx);
+
+ $(node.tr).removeClass("fancytree-node");
+ // indent
+ indent = (node.getLevel() - 1) * opts.table.indentation;
+ if (opts.rtl) {
+ $(node.span).css({ paddingRight: indent + "px" });
+ } else {
+ $(node.span).css({ paddingLeft: indent + "px" });
+ }
+ },
+ /* Expand node, return Deferred.promise. */
+ nodeSetExpanded: function(ctx, flag, callOpts) {
+ var node = ctx.node,
+ tree = ctx.tree;
+
+ // flag defaults to true
+ flag = flag !== false;
+
+ if ((node.expanded && flag) || (!node.expanded && !flag)) {
+ // Expanded state isn't changed - just call base implementation
+ return this._superApply(arguments);
+ }
+
+ var dfd = new $.Deferred(),
+ subOpts = $.extend({}, callOpts, {
+ noEvents: true,
+ noAnimation: true,
+ });
+
+ callOpts = callOpts || {};
+
+ function _afterExpand(ok) {
+ tree.redrawViewport(true);
+
+ if (ok) {
+ if (
+ flag &&
+ ctx.options.autoScroll &&
+ !callOpts.noAnimation &&
+ node.hasChildren()
+ ) {
+ // Scroll down to last child, but keep current node visible
+ node.getLastChild()
+ .scrollIntoView(true, { topNode: node })
+ .always(function() {
+ if (!callOpts.noEvents) {
+ tree._triggerNodeEvent(
+ flag ? "expand" : "collapse",
+ ctx
+ );
+ }
+ dfd.resolveWith(node);
+ });
+ } else {
+ if (!callOpts.noEvents) {
+ tree._triggerNodeEvent(
+ flag ? "expand" : "collapse",
+ ctx
+ );
+ }
+ dfd.resolveWith(node);
+ }
+ } else {
+ if (!callOpts.noEvents) {
+ tree._triggerNodeEvent(
+ flag ? "expand" : "collapse",
+ ctx
+ );
+ }
+ dfd.rejectWith(node);
+ }
+ }
+ // Call base-expand with disabled events and animation
+ this._super(ctx, flag, subOpts)
+ .done(function() {
+ _afterExpand(true);
+ })
+ .fail(function() {
+ _afterExpand(false);
+ });
+ return dfd.promise();
+ },
+ treeClear: function(ctx) {
+ // this.nodeRemoveChildMarkup(this._makeHookContext(this.rootNode));
+ // this._renumberReset(); // Invalidate visible row cache
+ return this._superApply(arguments);
+ },
+ treeDestroy: function(ctx) {
+ this.$container.find("tbody").empty();
+ if (this.$source) {
+ this.$source.removeClass("fancytree-helper-hidden");
+ }
+ this._renumberReset(); // Invalidate visible row cache
+ return this._superApply(arguments);
+ },
+ treeStructureChanged: function(ctx, type) {
+ // debugger;
+ if (type !== "addNode" || ctx.tree.visibleNodeList) {
+ // this.debug("treeStructureChanged(" + type + ")");
+ this._renumberReset(); // Invalidate visible row cache
+ }
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.gridnav.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.gridnav.js
new file mode 100644
index 0000000..a3a0c49
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.gridnav.js
@@ -0,0 +1,223 @@
+/*!
+ * jquery.fancytree.gridnav.js
+ *
+ * Support keyboard navigation for trees with embedded input controls.
+ * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/)
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ *
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define([
+ "jquery",
+ "./jquery.fancytree",
+ "./jquery.fancytree.table",
+ ], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree.table"); // core + table
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ /*******************************************************************************
+ * Private functions and variables
+ */
+
+ // Allow these navigation keys even when input controls are focused
+
+ var KC = $.ui.keyCode,
+ // which keys are *not* handled by embedded control, but passed to tree
+ // navigation handler:
+ NAV_KEYS = {
+ text: [KC.UP, KC.DOWN],
+ checkbox: [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT],
+ link: [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT],
+ radiobutton: [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT],
+ "select-one": [KC.LEFT, KC.RIGHT],
+ "select-multiple": [KC.LEFT, KC.RIGHT],
+ };
+
+ /* Calculate TD column index (considering colspans).*/
+ function getColIdx($tr, $td) {
+ var colspan,
+ td = $td.get(0),
+ idx = 0;
+
+ $tr.children().each(function() {
+ if (this === td) {
+ return false;
+ }
+ colspan = $(this).prop("colspan");
+ idx += colspan ? colspan : 1;
+ });
+ return idx;
+ }
+
+ /* Find TD at given column index (considering colspans).*/
+ function findTdAtColIdx($tr, colIdx) {
+ var colspan,
+ res = null,
+ idx = 0;
+
+ $tr.children().each(function() {
+ if (idx >= colIdx) {
+ res = $(this);
+ return false;
+ }
+ colspan = $(this).prop("colspan");
+ idx += colspan ? colspan : 1;
+ });
+ return res;
+ }
+
+ /* Find adjacent cell for a given direction. Skip empty cells and consider merged cells */
+ function findNeighbourTd($target, keyCode) {
+ var $tr,
+ colIdx,
+ $td = $target.closest("td"),
+ $tdNext = null;
+
+ switch (keyCode) {
+ case KC.LEFT:
+ $tdNext = $td.prev();
+ break;
+ case KC.RIGHT:
+ $tdNext = $td.next();
+ break;
+ case KC.UP:
+ case KC.DOWN:
+ $tr = $td.parent();
+ colIdx = getColIdx($tr, $td);
+ while (true) {
+ $tr = keyCode === KC.UP ? $tr.prev() : $tr.next();
+ if (!$tr.length) {
+ break;
+ }
+ // Skip hidden rows
+ if ($tr.is(":hidden")) {
+ continue;
+ }
+ // Find adjacent cell in the same column
+ $tdNext = findTdAtColIdx($tr, colIdx);
+ // Skip cells that don't conatain a focusable element
+ if ($tdNext && $tdNext.find(":input,a").length) {
+ break;
+ }
+ }
+ break;
+ }
+ return $tdNext;
+ }
+
+ /*******************************************************************************
+ * Extension code
+ */
+ $.ui.fancytree.registerExtension({
+ name: "gridnav",
+ version: "2.36.0",
+ // Default options for this extension.
+ options: {
+ autofocusInput: false, // Focus first embedded input if node gets activated
+ handleCursorKeys: true, // Allow UP/DOWN in inputs to move to prev/next node
+ },
+
+ treeInit: function(ctx) {
+ // gridnav requires the table extension to be loaded before itself
+ this._requireExtension("table", true, true);
+ this._superApply(arguments);
+
+ this.$container.addClass("fancytree-ext-gridnav");
+
+ // Activate node if embedded input gets focus (due to a click)
+ this.$container.on("focusin", function(event) {
+ var ctx2,
+ node = $.ui.fancytree.getNode(event.target);
+
+ if (node && !node.isActive()) {
+ // Call node.setActive(), but also pass the event
+ ctx2 = ctx.tree._makeHookContext(node, event);
+ ctx.tree._callHook("nodeSetActive", ctx2, true);
+ }
+ });
+ },
+ nodeSetActive: function(ctx, flag, callOpts) {
+ var $outer,
+ opts = ctx.options.gridnav,
+ node = ctx.node,
+ event = ctx.originalEvent || {},
+ triggeredByInput = $(event.target).is(":input");
+
+ flag = flag !== false;
+
+ this._superApply(arguments);
+
+ if (flag) {
+ if (ctx.options.titlesTabbable) {
+ if (!triggeredByInput) {
+ $(node.span)
+ .find("span.fancytree-title")
+ .focus();
+ node.setFocus();
+ }
+ // If one node is tabbable, the container no longer needs to be
+ ctx.tree.$container.attr("tabindex", "-1");
+ // ctx.tree.$container.removeAttr("tabindex");
+ } else if (opts.autofocusInput && !triggeredByInput) {
+ // Set focus to input sub input (if node was clicked, but not
+ // when TAB was pressed )
+ $outer = $(node.tr || node.span);
+ $outer
+ .find(":input:enabled")
+ .first()
+ .focus();
+ }
+ }
+ },
+ nodeKeydown: function(ctx) {
+ var inputType,
+ handleKeys,
+ $td,
+ opts = ctx.options.gridnav,
+ event = ctx.originalEvent,
+ $target = $(event.target);
+
+ if ($target.is(":input:enabled")) {
+ inputType = $target.prop("type");
+ } else if ($target.is("a")) {
+ inputType = "link";
+ }
+ // ctx.tree.debug("ext-gridnav nodeKeydown", event, inputType);
+
+ if (inputType && opts.handleCursorKeys) {
+ handleKeys = NAV_KEYS[inputType];
+ if (handleKeys && $.inArray(event.which, handleKeys) >= 0) {
+ $td = findNeighbourTd($target, event.which);
+ if ($td && $td.length) {
+ // ctx.node.debug("ignore keydown in input", event.which, handleKeys);
+ $td.find(":input:enabled,a").focus();
+ // Prevent Fancytree default navigation
+ return false;
+ }
+ }
+ return true;
+ }
+ // ctx.tree.debug("ext-gridnav NOT HANDLED", event, inputType);
+ return this._superApply(arguments);
+ },
+ });
+ // Value returned by `require('jquery.fancytree..')`
+ return $.ui.fancytree;
+}); // End of closure
diff --git a/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.js b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.js
new file mode 100644
index 0000000..9bb5897
--- /dev/null
+++ b/admin/src/admin/static/vendor/fancytree/dist/modules/jquery.fancytree.js
@@ -0,0 +1,7313 @@
+/*!
+ * jquery.fancytree.js
+ * Tree view control with support for lazy loading and much more.
+ * https://github.com/mar10/fancytree/
+ *
+ * Copyright (c) 2008-2020, Martin Wendt (https://wwWendt.de)
+ * Released under the MIT license
+ * https://github.com/mar10/fancytree/wiki/LicenseInfo
+ *
+ * @version 2.36.0
+ * @date 2020-07-15T20:15:15Z
+ */
+
+/** Core Fancytree module.
+ */
+
+// UMD wrapper for the Fancytree core module
+(function(factory) {
+ if (typeof define === "function" && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(["jquery", "./jquery.fancytree.ui-deps"], factory);
+ } else if (typeof module === "object" && module.exports) {
+ // Node/CommonJS
+ require("./jquery.fancytree.ui-deps");
+ module.exports = factory(require("jquery"));
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+})(function($) {
+ "use strict";
+
+ // prevent duplicate loading
+ if ($.ui && $.ui.fancytree) {
+ $.ui.fancytree.warn("Fancytree: ignored duplicate include");
+ return;
+ }
+
+ /******************************************************************************
+ * Private functions and variables
+ */
+
+ var i,
+ attr,
+ FT = null, // initialized below
+ TEST_IMG = new RegExp(/\.|\//), // strings are considered image urls if they contain '.' or '/'
+ REX_HTML = /[&<>"'/]/g, // Escape those characters
+ REX_TOOLTIP = /[<>"'/]/g, // Don't escape `&` in tooltips
+ RECURSIVE_REQUEST_ERROR = "$recursive_request",
+ INVALID_REQUEST_TARGET_ERROR = "$request_target_invalid",
+ ENTITY_MAP = {
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': """,
+ "'": "'",
+ "/": "/",
+ },
+ IGNORE_KEYCODES = { 16: true, 17: true, 18: true },
+ SPECIAL_KEYCODES = {
+ 8: "backspace",
+ 9: "tab",
+ 10: "return",
+ 13: "return",
+ // 16: null, 17: null, 18: null, // ignore shift, ctrl, alt
+ 19: "pause",
+ 20: "capslock",
+ 27: "esc",
+ 32: "space",
+ 33: "pageup",
+ 34: "pagedown",
+ 35: "end",
+ 36: "home",
+ 37: "left",
+ 38: "up",
+ 39: "right",
+ 40: "down",
+ 45: "insert",
+ 46: "del",
+ 59: ";",
+ 61: "=",
+ // 91: null, 93: null, // ignore left and right meta
+ 96: "0",
+ 97: "1",
+ 98: "2",
+ 99: "3",
+ 100: "4",
+ 101: "5",
+ 102: "6",
+ 103: "7",
+ 104: "8",
+ 105: "9",
+ 106: "*",
+ 107: "+",
+ 109: "-",
+ 110: ".",
+ 111: "/",
+ 112: "f1",
+ 113: "f2",
+ 114: "f3",
+ 115: "f4",
+ 116: "f5",
+ 117: "f6",
+ 118: "f7",
+ 119: "f8",
+ 120: "f9",
+ 121: "f10",
+ 122: "f11",
+ 123: "f12",
+ 144: "numlock",
+ 145: "scroll",
+ 173: "-",
+ 186: ";",
+ 187: "=",
+ 188: ",",
+ 189: "-",
+ 190: ".",
+ 191: "/",
+ 192: "`",
+ 219: "[",
+ 220: "\\",
+ 221: "]",
+ 222: "'",
+ },
+ MODIFIERS = {
+ 16: "shift",
+ 17: "ctrl",
+ 18: "alt",
+ 91: "meta",
+ 93: "meta",
+ },
+ MOUSE_BUTTONS = { 0: "", 1: "left", 2: "middle", 3: "right" },
+ // Boolean attributes that can be set with equivalent class names in the LI tags
+ // Note: v2.23: checkbox and hideCheckbox are *not* in this list
+ CLASS_ATTRS = "active expanded focus folder lazy radiogroup selected unselectable unselectableIgnore".split(
+ " "
+ ),
+ CLASS_ATTR_MAP = {},
+ // Top-level Fancytree attributes, that can be set by dict
+ TREE_ATTRS = "columns types".split(" "),
+ // TREE_ATTR_MAP = {},
+ // Top-level FancytreeNode attributes, that can be set by dict
+ NODE_ATTRS = "checkbox expanded extraClasses folder icon iconTooltip key lazy partsel radiogroup refKey selected statusNodeType title tooltip type unselectable unselectableIgnore unselectableStatus".split(
+ " "
+ ),
+ NODE_ATTR_MAP = {},
+ // Mapping of lowercase -> real name (because HTML5 data-... attribute only supports lowercase)
+ NODE_ATTR_LOWERCASE_MAP = {},
+ // Attribute names that should NOT be added to node.data
+ NONE_NODE_DATA_MAP = {
+ active: true,
+ children: true,
+ data: true,
+ focus: true,
+ };
+
+ for (i = 0; i < CLASS_ATTRS.length; i++) {
+ CLASS_ATTR_MAP[CLASS_ATTRS[i]] = true;
+ }
+ for (i = 0; i < NODE_ATTRS.length; i++) {
+ attr = NODE_ATTRS[i];
+ NODE_ATTR_MAP[attr] = true;
+ if (attr !== attr.toLowerCase()) {
+ NODE_ATTR_LOWERCASE_MAP[attr.toLowerCase()] = attr;
+ }
+ }
+ // for(i=0; i t;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Deep-merge a list of objects (but replace array-type options).
+ *
+ * jQuery's $.extend(true, ...) method does a deep merge, that also merges Arrays.
+ * This variant is used to merge extension defaults with user options, and should
+ * merge objects, but override arrays (for example the `triggerStart: [...]` option
+ * of ext-edit). Also `null` values are copied over and not skipped.
+ *
+ * See issue #876
+ *
+ * Example:
+ * _simpleDeepMerge({}, o1, o2);
+ */
+ function _simpleDeepMerge() {
+ var options,
+ name,
+ src,
+ copy,
+ clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length;
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !$.isFunction(target)) {
+ target = {};
+ }
+ if (i === length) {
+ throw Error("need at least two args");
+ }
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[i]) != null) {
+ // Extend the base object
+ for (name in options) {
+ if (options.hasOwnProperty(name)) {
+ src = target[name];
+ copy = options[name];
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+ // Recurse if we're merging plain objects
+ // (NOTE: unlike $.extend, we don't merge arrays, but replace them)
+ if (copy && $.isPlainObject(copy)) {
+ clone = src && $.isPlainObject(src) ? src : {};
+ // Never move original objects, clone them
+ target[name] = _simpleDeepMerge(clone, copy);
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ target[name] = copy;
+ }
+ }
+ }
+ }
+ }
+ // Return the modified object
+ return target;
+ }
+
+ /** Return a wrapper that calls sub.methodName() and exposes
+ * this : tree
+ * this._local : tree.ext.EXTNAME
+ * this._super : base.methodName.call()
+ * this._superApply : base.methodName.apply()
+ */
+ function _makeVirtualFunction(methodName, tree, base, extension, extName) {
+ // $.ui.fancytree.debug("_makeVirtualFunction", methodName, tree, base, extension, extName);
+ // if(rexTestSuper && !rexTestSuper.test(func)){
+ // // extension.methodName() doesn't call _super(), so no wrapper required
+ // return func;
+ // }
+ // Use an immediate function as closure
+ var proxy = (function() {
+ var prevFunc = tree[methodName], // org. tree method or prev. proxy
+ baseFunc = extension[methodName], //
+ _local = tree.ext[extName],
+ _super = function() {
+ return prevFunc.apply(tree, arguments);
+ },
+ _superApply = function(args) {
+ return prevFunc.apply(tree, args);
+ };
+
+ // Return the wrapper function
+ return function() {
+ var prevLocal = tree._local,
+ prevSuper = tree._super,
+ prevSuperApply = tree._superApply;
+
+ try {
+ tree._local = _local;
+ tree._super = _super;
+ tree._superApply = _superApply;
+ return baseFunc.apply(tree, arguments);
+ } finally {
+ tree._local = prevLocal;
+ tree._super = prevSuper;
+ tree._superApply = prevSuperApply;
+ }
+ };
+ })(); // end of Immediate Function
+ return proxy;
+ }
+
+ /**
+ * Subclass `base` by creating proxy functions
+ */
+ function _subclassObject(tree, base, extension, extName) {
+ // $.ui.fancytree.debug("_subclassObject", tree, base, extension, extName);
+ for (var attrName in extension) {
+ if (typeof extension[attrName] === "function") {
+ if (typeof tree[attrName] === "function") {
+ // override existing method
+ tree[attrName] = _makeVirtualFunction(
+ attrName,
+ tree,
+ base,
+ extension,
+ extName
+ );
+ } else if (attrName.charAt(0) === "_") {
+ // Create private methods in tree.ext.EXTENSION namespace
+ tree.ext[extName][attrName] = _makeVirtualFunction(
+ attrName,
+ tree,
+ base,
+ extension,
+ extName
+ );
+ } else {
+ $.error(
+ "Could not override tree." +
+ attrName +
+ ". Use prefix '_' to create tree." +
+ extName +
+ "._" +
+ attrName
+ );
+ }
+ } else {
+ // Create member variables in tree.ext.EXTENSION namespace
+ if (attrName !== "options") {
+ tree.ext[extName][attrName] = extension[attrName];
+ }
+ }
+ }
+ }
+
+ function _getResolvedPromise(context, argArray) {
+ if (context === undefined) {
+ return $.Deferred(function() {
+ this.resolve();
+ }).promise();
+ }
+ return $.Deferred(function() {
+ this.resolveWith(context, argArray);
+ }).promise();
+ }
+
+ function _getRejectedPromise(context, argArray) {
+ if (context === undefined) {
+ return $.Deferred(function() {
+ this.reject();
+ }).promise();
+ }
+ return $.Deferred(function() {
+ this.rejectWith(context, argArray);
+ }).promise();
+ }
+
+ function _makeResolveFunc(deferred, context) {
+ return function() {
+ deferred.resolveWith(context);
+ };
+ }
+
+ function _getElementDataAsDict($el) {
+ // Evaluate 'data-NAME' attributes with special treatment for 'data-json'.
+ var d = $.extend({}, $el.data()),
+ json = d.json;
+
+ delete d.fancytree; // added to container by widget factory (old jQuery UI)
+ delete d.uiFancytree; // added to container by widget factory
+
+ if (json) {
+ delete d.json;
+ // is already returned as object (http://api.jquery.com/data/#data-html5)
+ d = $.extend(d, json);
+ }
+ return d;
+ }
+
+ function _escapeTooltip(s) {
+ return ("" + s).replace(REX_TOOLTIP, function(s) {
+ return ENTITY_MAP[s];
+ });
+ }
+
+ // TODO: use currying
+ function _makeNodeTitleMatcher(s) {
+ s = s.toLowerCase();
+ return function(node) {
+ return node.title.toLowerCase().indexOf(s) >= 0;
+ };
+ }
+
+ function _makeNodeTitleStartMatcher(s) {
+ var reMatch = new RegExp("^" + s, "i");
+ return function(node) {
+ return reMatch.test(node.title);
+ };
+ }
+
+ /******************************************************************************
+ * FancytreeNode
+ */
+
+ /**
+ * Creates a new FancytreeNode
+ *
+ * @class FancytreeNode
+ * @classdesc A FancytreeNode represents the hierarchical data model and operations.
+ *
+ * @param {FancytreeNode} parent
+ * @param {NodeData} obj
+ *
+ * @property {Fancytree} tree The tree instance
+ * @property {FancytreeNode} parent The parent node
+ * @property {string} key Node id (must be unique inside the tree)
+ * @property {string} title Display name (may contain HTML)
+ * @property {object} data Contains all extra data that was passed on node creation
+ * @property {FancytreeNode[] | null | undefined} children Array of child nodes.`. tag
+ this.statusNodeType = null; // if this is a temp. node to display the status of its parent
+ this._isLoading = false; // if this node itself is loading
+ this._error = null; // {message: '...'} if a load error occurred
+ this.data = {};
+
+ // TODO: merge this code with node.toDict()
+ // copy attributes from obj object
+ for (i = 0, l = NODE_ATTRS.length; i < l; i++) {
+ name = NODE_ATTRS[i];
+ this[name] = obj[name];
+ }
+ // unselectableIgnore and unselectableStatus imply unselectable
+ if (
+ this.unselectableIgnore != null ||
+ this.unselectableStatus != null
+ ) {
+ this.unselectable = true;
+ }
+ if (obj.hideCheckbox) {
+ $.error(
+ "'hideCheckbox' node option was removed in v2.23.0: use 'checkbox: false'"
+ );
+ }
+ // node.data += obj.data
+ if (obj.data) {
+ $.extend(this.data, obj.data);
+ }
+ // Copy all other attributes to this.data.NAME
+ for (name in obj) {
+ if (
+ !NODE_ATTR_MAP[name] &&
+ (this.tree.options.copyFunctionsToData ||
+ !$.isFunction(obj[name])) &&
+ !NONE_NODE_DATA_MAP[name]
+ ) {
+ // node.data.NAME = obj.NAME
+ this.data[name] = obj[name];
+ }
+ }
+
+ // Fix missing key
+ if (this.key == null) {
+ // test for null OR undefined
+ if (this.tree.options.defaultKey) {
+ this.key = "" + this.tree.options.defaultKey(this);
+ _assert(this.key, "defaultKey() must return a unique key");
+ } else {
+ this.key = "_" + FT._nextNodeKey++;
+ }
+ } else {
+ this.key = "" + this.key; // Convert to string (#217)
+ }
+
+ // Fix tree.activeNode
+ // TODO: not elegant: we use obj.active as marker to set tree.activeNode
+ // when loading from a dictionary.
+ if (obj.active) {
+ _assert(
+ this.tree.activeNode === null,
+ "only one active node allowed"
+ );
+ this.tree.activeNode = this;
+ }
+ if (obj.selected) {
+ // #186
+ this.tree.lastSelectedNode = this;
+ }
+ // TODO: handle obj.focus = true
+
+ // Create child nodes
+ cl = obj.children;
+ if (cl) {
+ if (cl.length) {
+ this._setChildren(cl);
+ } else {
+ // if an empty array was passed for a lazy node, keep it, in order to mark it 'loaded'
+ this.children = this.lazy ? [] : null;
+ }
+ } else {
+ this.children = null;
+ }
+ // Add to key/ref map (except for root node)
+ // if( parent ) {
+ this.tree._callHook("treeRegisterNode", this.tree, true, this);
+ // }
+ }
+
+ FancytreeNode.prototype = /** @lends FancytreeNode# */ {
+ /* Return the direct child FancytreeNode with a given key, index. */
+ _findDirectChild: function(ptr) {
+ var i,
+ l,
+ cl = this.children;
+
+ if (cl) {
+ if (typeof ptr === "string") {
+ for (i = 0, l = cl.length; i < l; i++) {
+ if (cl[i].key === ptr) {
+ return cl[i];
+ }
+ }
+ } else if (typeof ptr === "number") {
+ return this.children[ptr];
+ } else if (ptr.parent === this) {
+ return ptr;
+ }
+ }
+ return null;
+ },
+ // TODO: activate()
+ // TODO: activateSilently()
+ /* Internal helper called in recursive addChildren sequence.*/
+ _setChildren: function(children) {
+ _assert(
+ children && (!this.children || this.children.length === 0),
+ "only init supported"
+ );
+ this.children = [];
+ for (var i = 0, l = children.length; i < l; i++) {
+ this.children.push(new FancytreeNode(this, children[i]));
+ }
+ this.tree._callHook(
+ "treeStructureChanged",
+ this.tree,
+ "setChildren"
+ );
+ },
+ /**
+ * Append (or insert) a list of child nodes.
+ *
+ * @param {NodeData[]} children array of child node definitions (also single child accepted)
+ * @param {FancytreeNode | string | Integer} [insertBefore] child node (or key or index of such).
+ * If omitted, the new children are appended.
+ * @returns {FancytreeNode} first child added
+ *
+ * @see FancytreeNode#applyPatch
+ */
+ addChildren: function(children, insertBefore) {
+ var i,
+ l,
+ pos,
+ origFirstChild = this.getFirstChild(),
+ origLastChild = this.getLastChild(),
+ firstNode = null,
+ nodeList = [];
+
+ if ($.isPlainObject(children)) {
+ children = [children];
+ }
+ if (!this.children) {
+ this.children = [];
+ }
+ for (i = 0, l = children.length; i < l; i++) {
+ nodeList.push(new FancytreeNode(this, children[i]));
+ }
+ firstNode = nodeList[0];
+ if (insertBefore == null) {
+ this.children = this.children.concat(nodeList);
+ } else {
+ // Returns null if insertBefore is not a direct child:
+ insertBefore = this._findDirectChild(insertBefore);
+ pos = $.inArray(insertBefore, this.children);
+ _assert(pos >= 0, "insertBefore must be an existing child");
+ // insert nodeList after children[pos]
+ this.children.splice.apply(
+ this.children,
+ [pos, 0].concat(nodeList)
+ );
+ }
+ if (origFirstChild && !insertBefore) {
+ // #708: Fast path -- don't render every child of root, just the new ones!
+ // #723, #729: but only if it's appended to an existing child list
+ for (i = 0, l = nodeList.length; i < l; i++) {
+ nodeList[i].render(); // New nodes were never rendered before
+ }
+ // Adjust classes where status may have changed
+ // Has a first child
+ if (origFirstChild !== this.getFirstChild()) {
+ // Different first child -- recompute classes
+ origFirstChild.renderStatus();
+ }
+ if (origLastChild !== this.getLastChild()) {
+ // Different last child -- recompute classes
+ origLastChild.renderStatus();
+ }
+ } else if (!this.parent || this.parent.ul || this.tr) {
+ // render if the parent was rendered (or this is a root node)
+ this.render();
+ }
+ if (this.tree.options.selectMode === 3) {
+ this.fixSelection3FromEndNodes();
+ }
+ this.triggerModifyChild(
+ "add",
+ nodeList.length === 1 ? nodeList[0] : null
+ );
+ return firstNode;
+ },
+ /**
+ * Add class to node's span tag and to .extraClasses.
+ *
+ * @param {string} className class name
+ *
+ * @since 2.17
+ */
+ addClass: function(className) {
+ return this.toggleClass(className, true);
+ },
+ /**
+ * Append or prepend a node, or append a child node.
+ *
+ * This a convenience function that calls addChildren()
+ *
+ * @param {NodeData} node node definition
+ * @param {string} [mode=child] 'before', 'after', 'firstChild', or 'child' ('over' is a synonym for 'child')
+ * @returns {FancytreeNode} new node
+ */
+ addNode: function(node, mode) {
+ if (mode === undefined || mode === "over") {
+ mode = "child";
+ }
+ switch (mode) {
+ case "after":
+ return this.getParent().addChildren(
+ node,
+ this.getNextSibling()
+ );
+ case "before":
+ return this.getParent().addChildren(node, this);
+ case "firstChild":
+ // Insert before the first child if any
+ var insertBefore = this.children ? this.children[0] : null;
+ return this.addChildren(node, insertBefore);
+ case "child":
+ case "over":
+ return this.addChildren(node);
+ }
+ _assert(false, "Invalid mode: " + mode);
+ },
+ /**Add child status nodes that indicate 'More...', etc.
+ *
+ * This also maintains the node's `partload` property.
+ * @param {boolean|object} node optional node definition. Pass `false` to remove all paging nodes.
+ * @param {string} [mode='child'] 'child'|firstChild'
+ * @since 2.15
+ */
+ addPagingNode: function(node, mode) {
+ var i, n;
+
+ mode = mode || "child";
+ if (node === false) {
+ for (i = this.children.length - 1; i >= 0; i--) {
+ n = this.children[i];
+ if (n.statusNodeType === "paging") {
+ this.removeChild(n);
+ }
+ }
+ this.partload = false;
+ return;
+ }
+ node = $.extend(
+ {
+ title: this.tree.options.strings.moreData,
+ statusNodeType: "paging",
+ icon: false,
+ },
+ node
+ );
+ this.partload = true;
+ return this.addNode(node, mode);
+ },
+ /**
+ * Append new node after this.
+ *
+ * This a convenience function that calls addNode(node, 'after')
+ *
+ * @param {NodeData} node node definition
+ * @returns {FancytreeNode} new node
+ */
+ appendSibling: function(node) {
+ return this.addNode(node, "after");
+ },
+ /**
+ * (experimental) Apply a modification (or navigation) operation.
+ *
+ * @param {string} cmd
+ * @param {object} [opts]
+ * @see Fancytree#applyCommand
+ * @since 2.32
+ */
+ applyCommand: function(cmd, opts) {
+ return this.tree.applyCommand(cmd, this, opts);
+ },
+ /**
+ * Modify existing child nodes.
+ *
+ * @param {NodePatch} patch
+ * @returns {$.Promise}
+ * @see FancytreeNode#addChildren
+ */
+ applyPatch: function(patch) {
+ // patch [key, null] means 'remove'
+ if (patch === null) {
+ this.remove();
+ return _getResolvedPromise(this);
+ }
+ // TODO: make sure that root node is not collapsed or modified
+ // copy (most) attributes to node.ATTR or node.data.ATTR
+ var name,
+ promise,
+ v,
+ IGNORE_MAP = { children: true, expanded: true, parent: true }; // TODO: should be global
+
+ for (name in patch) {
+ if (patch.hasOwnProperty(name)) {
+ v = patch[name];
+ if (!IGNORE_MAP[name] && !$.isFunction(v)) {
+ if (NODE_ATTR_MAP[name]) {
+ this[name] = v;
+ } else {
+ this.data[name] = v;
+ }
+ }
+ }
+ }
+ // Remove and/or create children
+ if (patch.hasOwnProperty("children")) {
+ this.removeChildren();
+ if (patch.children) {
+ // only if not null and not empty list
+ // TODO: addChildren instead?
+ this._setChildren(patch.children);
+ }
+ // TODO: how can we APPEND or INSERT child nodes?
+ }
+ if (this.isVisible()) {
+ this.renderTitle();
+ this.renderStatus();
+ }
+ // Expand collapse (final step, since this may be async)
+ if (patch.hasOwnProperty("expanded")) {
+ promise = this.setExpanded(patch.expanded);
+ } else {
+ promise = _getResolvedPromise(this);
+ }
+ return promise;
+ },
+ /** Collapse all sibling nodes.
+ * @returns {$.Promise}
+ */
+ collapseSiblings: function() {
+ return this.tree._callHook("nodeCollapseSiblings", this);
+ },
+ /** Copy this node as sibling or child of `node`.
+ *
+ * @param {FancytreeNode} node source node
+ * @param {string} [mode=child] 'before' | 'after' | 'child'
+ * @param {Function} [map] callback function(NodeData, FancytreeNode) that could modify the new node
+ * @returns {FancytreeNode} new
+ */
+ copyTo: function(node, mode, map) {
+ return node.addNode(this.toDict(true, map), mode);
+ },
+ /** Count direct and indirect children.
+ *
+ * @param {boolean} [deep=true] pass 'false' to only count direct children
+ * @returns {int} number of child nodes
+ */
+ countChildren: function(deep) {
+ var cl = this.children,
+ i,
+ l,
+ n;
+ if (!cl) {
+ return 0;
+ }
+ n = cl.length;
+ if (deep !== false) {
+ for (i = 0, l = n; i < l; i++) {
+ n += cl[i].countChildren();
+ }
+ }
+ return n;
+ },
+ // TODO: deactivate()
+ /** Write to browser console if debugLevel >= 4 (prepending node info)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ debug: function(msg) {
+ if (this.tree.options.debugLevel >= 4) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("log", arguments);
+ }
+ },
+ /** Deprecated.
+ * @deprecated since 2014-02-16. Use resetLazy() instead.
+ */
+ discard: function() {
+ this.warn(
+ "FancytreeNode.discard() is deprecated since 2014-02-16. Use .resetLazy() instead."
+ );
+ return this.resetLazy();
+ },
+ /** Remove DOM elements for all descendents. May be called on .collapse event
+ * to keep the DOM small.
+ * @param {boolean} [includeSelf=false]
+ */
+ discardMarkup: function(includeSelf) {
+ var fn = includeSelf ? "nodeRemoveMarkup" : "nodeRemoveChildMarkup";
+ this.tree._callHook(fn, this);
+ },
+ /** Write error to browser console if debugLevel >= 1 (prepending tree info)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ error: function(msg) {
+ if (this.tree.options.debugLevel >= 1) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("error", arguments);
+ }
+ },
+ /**Find all nodes that match condition (excluding self).
+ *
+ * @param {string | function(node)} match title string to search for, or a
+ * callback function that returns `true` if a node is matched.
+ * @returns {FancytreeNode[]} array of nodes (may be empty)
+ */
+ findAll: function(match) {
+ match = $.isFunction(match) ? match : _makeNodeTitleMatcher(match);
+ var res = [];
+ this.visit(function(n) {
+ if (match(n)) {
+ res.push(n);
+ }
+ });
+ return res;
+ },
+ /**Find first node that matches condition (excluding self).
+ *
+ * @param {string | function(node)} match title string to search for, or a
+ * callback function that returns `true` if a node is matched.
+ * @returns {FancytreeNode} matching node or null
+ * @see FancytreeNode#findAll
+ */
+ findFirst: function(match) {
+ match = $.isFunction(match) ? match : _makeNodeTitleMatcher(match);
+ var res = null;
+ this.visit(function(n) {
+ if (match(n)) {
+ res = n;
+ return false;
+ }
+ });
+ return res;
+ },
+ /** Find a node relative to self.
+ *
+ * @param {number|string} where The keyCode that would normally trigger this move,
+ * or a keyword ('down', 'first', 'last', 'left', 'parent', 'right', 'up').
+ * @returns {FancytreeNode}
+ * @since v2.31
+ */
+ findRelatedNode: function(where, includeHidden) {
+ return this.tree.findRelatedNode(this, where, includeHidden);
+ },
+ /* Apply selection state (internal use only) */
+ _changeSelectStatusAttrs: function(state) {
+ var changed = false,
+ opts = this.tree.options,
+ unselectable = FT.evalOption(
+ "unselectable",
+ this,
+ this,
+ opts,
+ false
+ ),
+ unselectableStatus = FT.evalOption(
+ "unselectableStatus",
+ this,
+ this,
+ opts,
+ undefined
+ );
+
+ if (unselectable && unselectableStatus != null) {
+ state = unselectableStatus;
+ }
+ switch (state) {
+ case false:
+ changed = this.selected || this.partsel;
+ this.selected = false;
+ this.partsel = false;
+ break;
+ case true:
+ changed = !this.selected || !this.partsel;
+ this.selected = true;
+ this.partsel = true;
+ break;
+ case undefined:
+ changed = this.selected || !this.partsel;
+ this.selected = false;
+ this.partsel = true;
+ break;
+ default:
+ _assert(false, "invalid state: " + state);
+ }
+ // this.debug("fixSelection3AfterLoad() _changeSelectStatusAttrs()", state, changed);
+ if (changed) {
+ this.renderStatus();
+ }
+ return changed;
+ },
+ /**
+ * Fix selection status, after this node was (de)selected in multi-hier mode.
+ * This includes (de)selecting all children.
+ */
+ fixSelection3AfterClick: function(callOpts) {
+ var flag = this.isSelected();
+
+ // this.debug("fixSelection3AfterClick()");
+
+ this.visit(function(node) {
+ node._changeSelectStatusAttrs(flag);
+ if (node.radiogroup) {
+ // #931: don't (de)select this branch
+ return "skip";
+ }
+ });
+ this.fixSelection3FromEndNodes(callOpts);
+ },
+ /**
+ * Fix selection status for multi-hier mode.
+ * Only end-nodes are considered to update the descendants branch and parents.
+ * Should be called after this node has loaded new children or after
+ * children have been modified using the API.
+ */
+ fixSelection3FromEndNodes: function(callOpts) {
+ var opts = this.tree.options;
+
+ // this.debug("fixSelection3FromEndNodes()");
+ _assert(opts.selectMode === 3, "expected selectMode 3");
+
+ // Visit all end nodes and adjust their parent's `selected` and `partsel`
+ // attributes. Return selection state true, false, or undefined.
+ function _walk(node) {
+ var i,
+ l,
+ child,
+ s,
+ state,
+ allSelected,
+ someSelected,
+ unselIgnore,
+ unselState,
+ children = node.children;
+
+ if (children && children.length) {
+ // check all children recursively
+ allSelected = true;
+ someSelected = false;
+
+ for (i = 0, l = children.length; i < l; i++) {
+ child = children[i];
+ // the selection state of a node is not relevant; we need the end-nodes
+ s = _walk(child);
+ // if( !child.unselectableIgnore ) {
+ unselIgnore = FT.evalOption(
+ "unselectableIgnore",
+ child,
+ child,
+ opts,
+ false
+ );
+ if (!unselIgnore) {
+ if (s !== false) {
+ someSelected = true;
+ }
+ if (s !== true) {
+ allSelected = false;
+ }
+ }
+ }
+ // eslint-disable-next-line no-nested-ternary
+ state = allSelected
+ ? true
+ : someSelected
+ ? undefined
+ : false;
+ } else {
+ // This is an end-node: simply report the status
+ unselState = FT.evalOption(
+ "unselectableStatus",
+ node,
+ node,
+ opts,
+ undefined
+ );
+ state = unselState == null ? !!node.selected : !!unselState;
+ }
+ // #939: Keep a `partsel` flag that was explicitly set on a lazy node
+ if (
+ node.partsel &&
+ !node.selected &&
+ node.lazy &&
+ node.children == null
+ ) {
+ state = undefined;
+ }
+ node._changeSelectStatusAttrs(state);
+ return state;
+ }
+ _walk(this);
+
+ // Update parent's state
+ this.visitParents(function(node) {
+ var i,
+ l,
+ child,
+ state,
+ unselIgnore,
+ unselState,
+ children = node.children,
+ allSelected = true,
+ someSelected = false;
+
+ for (i = 0, l = children.length; i < l; i++) {
+ child = children[i];
+ unselIgnore = FT.evalOption(
+ "unselectableIgnore",
+ child,
+ child,
+ opts,
+ false
+ );
+ if (!unselIgnore) {
+ unselState = FT.evalOption(
+ "unselectableStatus",
+ child,
+ child,
+ opts,
+ undefined
+ );
+ state =
+ unselState == null
+ ? !!child.selected
+ : !!unselState;
+ // When fixing the parents, we trust the sibling status (i.e.
+ // we don't recurse)
+ if (state || child.partsel) {
+ someSelected = true;
+ }
+ if (!state) {
+ allSelected = false;
+ }
+ }
+ }
+ // eslint-disable-next-line no-nested-ternary
+ state = allSelected ? true : someSelected ? undefined : false;
+ node._changeSelectStatusAttrs(state);
+ });
+ },
+ // TODO: focus()
+ /**
+ * Update node data. If dict contains 'children', then also replace
+ * the hole sub tree.
+ * @param {NodeData} dict
+ *
+ * @see FancytreeNode#addChildren
+ * @see FancytreeNode#applyPatch
+ */
+ fromDict: function(dict) {
+ // copy all other attributes to this.data.xxx
+ for (var name in dict) {
+ if (NODE_ATTR_MAP[name]) {
+ // node.NAME = dict.NAME
+ this[name] = dict[name];
+ } else if (name === "data") {
+ // node.data += dict.data
+ $.extend(this.data, dict.data);
+ } else if (
+ !$.isFunction(dict[name]) &&
+ !NONE_NODE_DATA_MAP[name]
+ ) {
+ // node.data.NAME = dict.NAME
+ this.data[name] = dict[name];
+ }
+ }
+ if (dict.children) {
+ // recursively set children and render
+ this.removeChildren();
+ this.addChildren(dict.children);
+ }
+ this.renderTitle();
+ /*
+ var children = dict.children;
+ if(children === undefined){
+ this.data = $.extend(this.data, dict);
+ this.render();
+ return;
+ }
+ dict = $.extend({}, dict);
+ dict.children = undefined;
+ this.data = $.extend(this.data, dict);
+ this.removeChildren();
+ this.addChild(children);
+ */
+ },
+ /** Return the list of child nodes (undefined for unexpanded lazy nodes).
+ * @returns {FancytreeNode[] | undefined}
+ */
+ getChildren: function() {
+ if (this.hasChildren() === undefined) {
+ // TODO: only required for lazy nodes?
+ return undefined; // Lazy node: unloaded, currently loading, or load error
+ }
+ return this.children;
+ },
+ /** Return the first child node or null.
+ * @returns {FancytreeNode | null}
+ */
+ getFirstChild: function() {
+ return this.children ? this.children[0] : null;
+ },
+ /** Return the 0-based child index.
+ * @returns {int}
+ */
+ getIndex: function() {
+ // return this.parent.children.indexOf(this);
+ return $.inArray(this, this.parent.children); // indexOf doesn't work in IE7
+ },
+ /** Return the hierarchical child index (1-based, e.g. '3.2.4').
+ * @param {string} [separator="."]
+ * @param {int} [digits=1]
+ * @returns {string}
+ */
+ getIndexHier: function(separator, digits) {
+ separator = separator || ".";
+ var s,
+ res = [];
+ $.each(this.getParentList(false, true), function(i, o) {
+ s = "" + (o.getIndex() + 1);
+ if (digits) {
+ // prepend leading zeroes
+ s = ("0000000" + s).substr(-digits);
+ }
+ res.push(s);
+ });
+ return res.join(separator);
+ },
+ /** Return the parent keys separated by options.keyPathSeparator, e.g. "/id_1/id_17/id_32".
+ *
+ * (Unlike `node.getPath()`, this method prepends a "/" and inverts the first argument.)
+ *
+ * @see FancytreeNode#getPath
+ * @param {boolean} [excludeSelf=false]
+ * @returns {string}
+ */
+ getKeyPath: function(excludeSelf) {
+ var sep = this.tree.options.keyPathSeparator;
+
+ return sep + this.getPath(!excludeSelf, "key", sep);
+ },
+ /** Return the last child of this node or null.
+ * @returns {FancytreeNode | null}
+ */
+ getLastChild: function() {
+ return this.children
+ ? this.children[this.children.length - 1]
+ : null;
+ },
+ /** Return node depth. 0: System root node, 1: visible top-level node, 2: first sub-level, ... .
+ * @returns {int}
+ */
+ getLevel: function() {
+ var level = 0,
+ dtn = this.parent;
+ while (dtn) {
+ level++;
+ dtn = dtn.parent;
+ }
+ return level;
+ },
+ /** Return the successor node (under the same parent) or null.
+ * @returns {FancytreeNode | null}
+ */
+ getNextSibling: function() {
+ // TODO: use indexOf, if available: (not in IE6)
+ if (this.parent) {
+ var i,
+ l,
+ ac = this.parent.children;
+
+ for (i = 0, l = ac.length - 1; i < l; i++) {
+ // up to length-2, so next(last) = null
+ if (ac[i] === this) {
+ return ac[i + 1];
+ }
+ }
+ }
+ return null;
+ },
+ /** Return the parent node (null for the system root node).
+ * @returns {FancytreeNode | null}
+ */
+ getParent: function() {
+ // TODO: return null for top-level nodes?
+ return this.parent;
+ },
+ /** Return an array of all parent nodes (top-down).
+ * @param {boolean} [includeRoot=false] Include the invisible system root node.
+ * @param {boolean} [includeSelf=false] Include the node itself.
+ * @returns {FancytreeNode[]}
+ */
+ getParentList: function(includeRoot, includeSelf) {
+ var l = [],
+ dtn = includeSelf ? this : this.parent;
+ while (dtn) {
+ if (includeRoot || dtn.parent) {
+ l.unshift(dtn);
+ }
+ dtn = dtn.parent;
+ }
+ return l;
+ },
+ /** Return a string representing the hierachical node path, e.g. "a/b/c".
+ * @param {boolean} [includeSelf=true]
+ * @param {string | function} [part="title"] node property name or callback
+ * @param {string} [separator="/"]
+ * @returns {string}
+ * @since v2.31
+ */
+ getPath: function(includeSelf, part, separator) {
+ includeSelf = includeSelf !== false;
+ part = part || "title";
+ separator = separator || "/";
+
+ var val,
+ path = [],
+ isFunc = $.isFunction(part);
+
+ this.visitParents(function(n) {
+ if (n.parent) {
+ val = isFunc ? part(n) : n[part];
+ path.unshift(val);
+ }
+ }, includeSelf);
+ return path.join(separator);
+ },
+ /** Return the predecessor node (under the same parent) or null.
+ * @returns {FancytreeNode | null}
+ */
+ getPrevSibling: function() {
+ if (this.parent) {
+ var i,
+ l,
+ ac = this.parent.children;
+
+ for (i = 1, l = ac.length; i < l; i++) {
+ // start with 1, so prev(first) = null
+ if (ac[i] === this) {
+ return ac[i - 1];
+ }
+ }
+ }
+ return null;
+ },
+ /**
+ * Return an array of selected descendant nodes.
+ * @param {boolean} [stopOnParents=false] only return the topmost selected
+ * node (useful with selectMode 3)
+ * @returns {FancytreeNode[]}
+ */
+ getSelectedNodes: function(stopOnParents) {
+ var nodeList = [];
+ this.visit(function(node) {
+ if (node.selected) {
+ nodeList.push(node);
+ if (stopOnParents === true) {
+ return "skip"; // stop processing this branch
+ }
+ }
+ });
+ return nodeList;
+ },
+ /** Return true if node has children. Return undefined if not sure, i.e. the node is lazy and not yet loaded).
+ * @returns {boolean | undefined}
+ */
+ hasChildren: function() {
+ if (this.lazy) {
+ if (this.children == null) {
+ // null or undefined: Not yet loaded
+ return undefined;
+ } else if (this.children.length === 0) {
+ // Loaded, but response was empty
+ return false;
+ } else if (
+ this.children.length === 1 &&
+ this.children[0].isStatusNode()
+ ) {
+ // Currently loading or load error
+ return undefined;
+ }
+ return true;
+ }
+ return !!(this.children && this.children.length);
+ },
+ /**
+ * Return true if node has `className` defined in .extraClasses.
+ *
+ * @param {string} className class name (separate multiple classes by space)
+ * @returns {boolean}
+ *
+ * @since 2.32
+ */
+ hasClass: function(className) {
+ return (
+ (" " + (this.extraClasses || "") + " ").indexOf(
+ " " + className + " "
+ ) >= 0
+ );
+ },
+ /** Return true if node has keyboard focus.
+ * @returns {boolean}
+ */
+ hasFocus: function() {
+ return this.tree.hasFocus() && this.tree.focusNode === this;
+ },
+ /** Write to browser console if debugLevel >= 3 (prepending node info)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ info: function(msg) {
+ if (this.tree.options.debugLevel >= 3) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("info", arguments);
+ }
+ },
+ /** Return true if node is active (see also FancytreeNode#isSelected).
+ * @returns {boolean}
+ */
+ isActive: function() {
+ return this.tree.activeNode === this;
+ },
+ /** Return true if node is vertically below `otherNode`, i.e. rendered in a subsequent row.
+ * @param {FancytreeNode} otherNode
+ * @returns {boolean}
+ * @since 2.28
+ */
+ isBelowOf: function(otherNode) {
+ return this.getIndexHier(".", 5) > otherNode.getIndexHier(".", 5);
+ },
+ /** Return true if node is a direct child of otherNode.
+ * @param {FancytreeNode} otherNode
+ * @returns {boolean}
+ */
+ isChildOf: function(otherNode) {
+ return this.parent && this.parent === otherNode;
+ },
+ /** Return true, if node is a direct or indirect sub node of otherNode.
+ * @param {FancytreeNode} otherNode
+ * @returns {boolean}
+ */
+ isDescendantOf: function(otherNode) {
+ if (!otherNode || otherNode.tree !== this.tree) {
+ return false;
+ }
+ var p = this.parent;
+ while (p) {
+ if (p === otherNode) {
+ return true;
+ }
+ if (p === p.parent) {
+ $.error("Recursive parent link: " + p);
+ }
+ p = p.parent;
+ }
+ return false;
+ },
+ /** Return true if node is expanded.
+ * @returns {boolean}
+ */
+ isExpanded: function() {
+ return !!this.expanded;
+ },
+ /** Return true if node is the first node of its parent's children.
+ * @returns {boolean}
+ */
+ isFirstSibling: function() {
+ var p = this.parent;
+ return !p || p.children[0] === this;
+ },
+ /** Return true if node is a folder, i.e. has the node.folder attribute set.
+ * @returns {boolean}
+ */
+ isFolder: function() {
+ return !!this.folder;
+ },
+ /** Return true if node is the last node of its parent's children.
+ * @returns {boolean}
+ */
+ isLastSibling: function() {
+ var p = this.parent;
+ return !p || p.children[p.children.length - 1] === this;
+ },
+ /** Return true if node is lazy (even if data was already loaded)
+ * @returns {boolean}
+ */
+ isLazy: function() {
+ return !!this.lazy;
+ },
+ /** Return true if node is lazy and loaded. For non-lazy nodes always return true.
+ * @returns {boolean}
+ */
+ isLoaded: function() {
+ return !this.lazy || this.hasChildren() !== undefined; // Also checks if the only child is a status node
+ },
+ /** Return true if children are currently beeing loaded, i.e. a Ajax request is pending.
+ * @returns {boolean}
+ */
+ isLoading: function() {
+ return !!this._isLoading;
+ },
+ /*
+ * @deprecated since v2.4.0: Use isRootNode() instead
+ */
+ isRoot: function() {
+ return this.isRootNode();
+ },
+ /** Return true if node is partially selected (tri-state).
+ * @returns {boolean}
+ * @since 2.23
+ */
+ isPartsel: function() {
+ return !this.selected && !!this.partsel;
+ },
+ /** (experimental) Return true if this is partially loaded.
+ * @returns {boolean}
+ * @since 2.15
+ */
+ isPartload: function() {
+ return !!this.partload;
+ },
+ /** Return true if this is the (invisible) system root node.
+ * @returns {boolean}
+ * @since 2.4
+ */
+ isRootNode: function() {
+ return this.tree.rootNode === this;
+ },
+ /** Return true if node is selected, i.e. has a checkmark set (see also FancytreeNode#isActive).
+ * @returns {boolean}
+ */
+ isSelected: function() {
+ return !!this.selected;
+ },
+ /** Return true if this node is a temporarily generated system node like
+ * 'loading', 'paging', or 'error' (node.statusNodeType contains the type).
+ * @returns {boolean}
+ */
+ isStatusNode: function() {
+ return !!this.statusNodeType;
+ },
+ /** Return true if this node is a status node of type 'paging'.
+ * @returns {boolean}
+ * @since 2.15
+ */
+ isPagingNode: function() {
+ return this.statusNodeType === "paging";
+ },
+ /** Return true if this a top level node, i.e. a direct child of the (invisible) system root node.
+ * @returns {boolean}
+ * @since 2.4
+ */
+ isTopLevel: function() {
+ return this.tree.rootNode === this.parent;
+ },
+ /** Return true if node is lazy and not yet loaded. For non-lazy nodes always return false.
+ * @returns {boolean}
+ */
+ isUndefined: function() {
+ return this.hasChildren() === undefined; // also checks if the only child is a status node
+ },
+ /** Return true if all parent nodes are expanded. Note: this does not check
+ * whether the node is scrolled into the visible part of the screen.
+ * @returns {boolean}
+ */
+ isVisible: function() {
+ var i,
+ l,
+ n,
+ hasFilter = this.tree.enableFilter,
+ parents = this.getParentList(false, false);
+
+ // TODO: check $(n.span).is(":visible")
+ // i.e. return false for nodes (but not parents) that are hidden
+ // by a filter
+ if (hasFilter && !this.match && !this.subMatchCount) {
+ // this.debug( "isVisible: HIDDEN (" + hasFilter + ", " + this.match + ", " + this.match + ")" );
+ return false;
+ }
+
+ for (i = 0, l = parents.length; i < l; i++) {
+ n = parents[i];
+
+ if (!n.expanded) {
+ // this.debug("isVisible: HIDDEN (parent collapsed)");
+ return false;
+ }
+ // if (hasFilter && !n.match && !n.subMatchCount) {
+ // this.debug("isVisible: HIDDEN (" + hasFilter + ", " + this.match + ", " + this.match + ")");
+ // return false;
+ // }
+ }
+ // this.debug("isVisible: VISIBLE");
+ return true;
+ },
+ /** Deprecated.
+ * @deprecated since 2014-02-16: use load() instead.
+ */
+ lazyLoad: function(discard) {
+ $.error(
+ "FancytreeNode.lazyLoad() is deprecated since 2014-02-16. Use .load() instead."
+ );
+ },
+ /**
+ * Load all children of a lazy node if neccessary. The expanded state is maintained.
+ * @param {boolean} [forceReload=false] Pass true to discard any existing nodes before. Otherwise this method does nothing if the node was already loaded.
+ * @returns {$.Promise}
+ */
+ load: function(forceReload) {
+ var res,
+ source,
+ self = this,
+ wasExpanded = this.isExpanded();
+
+ _assert(this.isLazy(), "load() requires a lazy node");
+ // _assert( forceReload || this.isUndefined(), "Pass forceReload=true to re-load a lazy node" );
+ if (!forceReload && !this.isUndefined()) {
+ return _getResolvedPromise(this);
+ }
+ if (this.isLoaded()) {
+ this.resetLazy(); // also collapses
+ }
+ // This method is also called by setExpanded() and loadKeyPath(), so we
+ // have to avoid recursion.
+ source = this.tree._triggerNodeEvent("lazyLoad", this);
+ if (source === false) {
+ // #69
+ return _getResolvedPromise(this);
+ }
+ _assert(
+ typeof source !== "boolean",
+ "lazyLoad event must return source in data.result"
+ );
+ res = this.tree._callHook("nodeLoadChildren", this, source);
+ if (wasExpanded) {
+ this.expanded = true;
+ res.always(function() {
+ self.render();
+ });
+ } else {
+ res.always(function() {
+ self.renderStatus(); // fix expander icon to 'loaded'
+ });
+ }
+ return res;
+ },
+ /** Expand all parents and optionally scroll into visible area as neccessary.
+ * Promise is resolved, when lazy loading and animations are done.
+ * @param {object} [opts] passed to `setExpanded()`.
+ * Defaults to {noAnimation: false, noEvents: false, scrollIntoView: true}
+ * @returns {$.Promise}
+ */
+ makeVisible: function(opts) {
+ var i,
+ self = this,
+ deferreds = [],
+ dfd = new $.Deferred(),
+ parents = this.getParentList(false, false),
+ len = parents.length,
+ effects = !(opts && opts.noAnimation === true),
+ scroll = !(opts && opts.scrollIntoView === false);
+
+ // Expand bottom-up, so only the top node is animated
+ for (i = len - 1; i >= 0; i--) {
+ // self.debug("pushexpand" + parents[i]);
+ deferreds.push(parents[i].setExpanded(true, opts));
+ }
+ $.when.apply($, deferreds).done(function() {
+ // All expands have finished
+ // self.debug("expand DONE", scroll);
+ if (scroll) {
+ self.scrollIntoView(effects).done(function() {
+ // self.debug("scroll DONE");
+ dfd.resolve();
+ });
+ } else {
+ dfd.resolve();
+ }
+ });
+ return dfd.promise();
+ },
+ /** Move this node to targetNode.
+ * @param {FancytreeNode} targetNode
+ * @param {string} mode
+ * 'child': append this node as last child of targetNode.
+ * This is the default. To be compatble with the D'n'd
+ * hitMode, we also accept 'over'.
+ * 'firstChild': add this node as first child of targetNode.
+ * 'before': add this node as sibling before targetNode.
+ * 'after': add this node as sibling after targetNode.
+ * @param {function} [map] optional callback(FancytreeNode) to allow modifcations
+ */
+ moveTo: function(targetNode, mode, map) {
+ if (mode === undefined || mode === "over") {
+ mode = "child";
+ } else if (mode === "firstChild") {
+ if (targetNode.children && targetNode.children.length) {
+ mode = "before";
+ targetNode = targetNode.children[0];
+ } else {
+ mode = "child";
+ }
+ }
+ var pos,
+ tree = this.tree,
+ prevParent = this.parent,
+ targetParent =
+ mode === "child" ? targetNode : targetNode.parent;
+
+ if (this === targetNode) {
+ return;
+ } else if (!this.parent) {
+ $.error("Cannot move system root");
+ } else if (targetParent.isDescendantOf(this)) {
+ $.error("Cannot move a node to its own descendant");
+ }
+ if (targetParent !== prevParent) {
+ prevParent.triggerModifyChild("remove", this);
+ }
+ // Unlink this node from current parent
+ if (this.parent.children.length === 1) {
+ if (this.parent === targetParent) {
+ return; // #258
+ }
+ this.parent.children = this.parent.lazy ? [] : null;
+ this.parent.expanded = false;
+ } else {
+ pos = $.inArray(this, this.parent.children);
+ _assert(pos >= 0, "invalid source parent");
+ this.parent.children.splice(pos, 1);
+ }
+ // Remove from source DOM parent
+ // if(this.parent.ul){
+ // this.parent.ul.removeChild(this.li);
+ // }
+
+ // Insert this node to target parent's child list
+ this.parent = targetParent;
+ if (targetParent.hasChildren()) {
+ switch (mode) {
+ case "child":
+ // Append to existing target children
+ targetParent.children.push(this);
+ break;
+ case "before":
+ // Insert this node before target node
+ pos = $.inArray(targetNode, targetParent.children);
+ _assert(pos >= 0, "invalid target parent");
+ targetParent.children.splice(pos, 0, this);
+ break;
+ case "after":
+ // Insert this node after target node
+ pos = $.inArray(targetNode, targetParent.children);
+ _assert(pos >= 0, "invalid target parent");
+ targetParent.children.splice(pos + 1, 0, this);
+ break;
+ default:
+ $.error("Invalid mode " + mode);
+ }
+ } else {
+ targetParent.children = [this];
+ }
+ // Parent has no tag yet:
+ // if( !targetParent.ul ) {
+ // // This is the parent's first child: create UL tag
+ // // (Hidden, because it will be
+ // targetParent.ul = document.createElement("ul");
+ // targetParent.ul.style.display = "none";
+ // targetParent.li.appendChild(targetParent.ul);
+ // }
+ // // Issue 319: Add to target DOM parent (only if node was already rendered(expanded))
+ // if(this.li){
+ // targetParent.ul.appendChild(this.li);
+ // }
+
+ // Let caller modify the nodes
+ if (map) {
+ targetNode.visit(map, true);
+ }
+ if (targetParent === prevParent) {
+ targetParent.triggerModifyChild("move", this);
+ } else {
+ // prevParent.triggerModifyChild("remove", this);
+ targetParent.triggerModifyChild("add", this);
+ }
+ // Handle cross-tree moves
+ if (tree !== targetNode.tree) {
+ // Fix node.tree for all source nodes
+ // _assert(false, "Cross-tree move is not yet implemented.");
+ this.warn("Cross-tree moveTo is experimental!");
+ this.visit(function(n) {
+ // TODO: fix selection state and activation, ...
+ n.tree = targetNode.tree;
+ }, true);
+ }
+
+ // A collaposed node won't re-render children, so we have to remove it manually
+ // if( !targetParent.expanded ){
+ // prevParent.ul.removeChild(this.li);
+ // }
+ tree._callHook("treeStructureChanged", tree, "moveTo");
+
+ // Update HTML markup
+ if (!prevParent.isDescendantOf(targetParent)) {
+ prevParent.render();
+ }
+ if (
+ !targetParent.isDescendantOf(prevParent) &&
+ targetParent !== prevParent
+ ) {
+ targetParent.render();
+ }
+ // TODO: fix selection state
+ // TODO: fix active state
+
+ /*
+ var tree = this.tree;
+ var opts = tree.options;
+ var pers = tree.persistence;
+
+ // Always expand, if it's below minExpandLevel
+ // tree.logDebug ("%s._addChildNode(%o), l=%o", this, ftnode, ftnode.getLevel());
+ if ( opts.minExpandLevel >= ftnode.getLevel() ) {
+ // tree.logDebug ("Force expand for %o", ftnode);
+ this.bExpanded = true;
+ }
+
+ // In multi-hier mode, update the parents selection state
+ // DT issue #82: only if not initializing, because the children may not exist yet
+ // if( !ftnode.data.isStatusNode() && opts.selectMode==3 && !isInitializing )
+ // ftnode._fixSelectionState();
+
+ // In multi-hier mode, update the parents selection state
+ if( ftnode.bSelected && opts.selectMode==3 ) {
+ var p = this;
+ while( p ) {
+ if( !p.hasSubSel )
+ p._setSubSel(true);
+ p = p.parent;
+ }
+ }
+ // render this node and the new child
+ if ( tree.bEnableUpdate )
+ this.render();
+ return ftnode;
+ */
+ },
+ /** Set focus relative to this node and optionally activate.
+ *
+ * 'left' collapses the node if it is expanded, or move to the parent
+ * otherwise.
+ * 'right' expands the node if it is collapsed, or move to the first
+ * child otherwise.
+ *
+ * @param {string|number} where 'down', 'first', 'last', 'left', 'parent', 'right', or 'up'.
+ * (Alternatively the keyCode that would normally trigger this move,
+ * e.g. `$.ui.keyCode.LEFT` = 'left'.
+ * @param {boolean} [activate=true]
+ * @returns {$.Promise}
+ */
+ navigate: function(where, activate) {
+ var node,
+ KC = $.ui.keyCode;
+
+ // Handle optional expand/collapse action for LEFT/RIGHT
+ switch (where) {
+ case "left":
+ case KC.LEFT:
+ if (this.expanded) {
+ return this.setExpanded(false);
+ }
+ break;
+ case "right":
+ case KC.RIGHT:
+ if (!this.expanded && (this.children || this.lazy)) {
+ return this.setExpanded();
+ }
+ break;
+ }
+ // Otherwise activate or focus the related node
+ node = this.findRelatedNode(where);
+ if (node) {
+ // setFocus/setActive will scroll later (if autoScroll is specified)
+ try {
+ node.makeVisible({ scrollIntoView: false });
+ } catch (e) {} // #272
+ if (activate === false) {
+ node.setFocus();
+ return _getResolvedPromise();
+ }
+ return node.setActive();
+ }
+ this.warn("Could not find related node '" + where + "'.");
+ return _getResolvedPromise();
+ },
+ /**
+ * Remove this node (not allowed for system root).
+ */
+ remove: function() {
+ return this.parent.removeChild(this);
+ },
+ /**
+ * Remove childNode from list of direct children.
+ * @param {FancytreeNode} childNode
+ */
+ removeChild: function(childNode) {
+ return this.tree._callHook("nodeRemoveChild", this, childNode);
+ },
+ /**
+ * Remove all child nodes and descendents. This converts the node into a leaf.
+ * It should only be neccessary to call this method after the node object
+ * was modified by direct access to its properties, because the common
+ * API methods (node.setTitle(), moveTo(), addChildren(), remove(), ...)
+ * already handle this.
+ * {@link FancytreeNode#renderTitle} and {@link FancytreeNode#renderStatus}
+ * are implied. If changes are more local, calling only renderTitle() or
+ * renderStatus() may be sufficient and faster.
+ *
+ *
+ * @param {boolean} [force=false] re-render, even if html markup was already created
+ * @param {boolean} [deep=false] also render all descendants, even if parent is collapsed
+ */
+ render: function(force, deep) {
+ return this.tree._callHook("nodeRender", this, force, deep);
+ },
+ /** Create HTML markup for the node's outer `` (expander, checkbox, icon, and title).
+ * Implies {@link FancytreeNode#renderStatus}.
+ * @see Fancytree_Hooks#nodeRenderTitle
+ */
+ renderTitle: function() {
+ return this.tree._callHook("nodeRenderTitle", this);
+ },
+ /** Update element's CSS classes according to node state.
+ * @see Fancytree_Hooks#nodeRenderStatus
+ */
+ renderStatus: function() {
+ return this.tree._callHook("nodeRenderStatus", this);
+ },
+ /**
+ * (experimental) Replace this node with `source`.
+ * (Currently only available for paging nodes.)
+ * @param {NodeData[]} source List of child node definitions
+ * @since 2.15
+ */
+ replaceWith: function(source) {
+ var res,
+ parent = this.parent,
+ pos = $.inArray(this, parent.children),
+ self = this;
+
+ _assert(
+ this.isPagingNode(),
+ "replaceWith() currently requires a paging status node"
+ );
+
+ res = this.tree._callHook("nodeLoadChildren", this, source);
+ res.done(function(data) {
+ // New nodes are currently children of `this`.
+ var children = self.children;
+ // Prepend newly loaded child nodes to `this`
+ // Move new children after self
+ for (i = 0; i < children.length; i++) {
+ children[i].parent = parent;
+ }
+ parent.children.splice.apply(
+ parent.children,
+ [pos + 1, 0].concat(children)
+ );
+
+ // Remove self
+ self.children = null;
+ self.remove();
+ // Redraw new nodes
+ parent.render();
+ // TODO: set node.partload = false if this was tha last paging node?
+ // parent.addPagingNode(false);
+ }).fail(function() {
+ self.setExpanded();
+ });
+ return res;
+ // $.error("Not implemented: replaceWith()");
+ },
+ /**
+ * Remove all children, collapse, and set the lazy-flag, so that the lazyLoad
+ * event is triggered on next expand.
+ */
+ resetLazy: function() {
+ this.removeChildren();
+ this.expanded = false;
+ this.lazy = true;
+ this.children = undefined;
+ this.renderStatus();
+ },
+ /** Schedule activity for delayed execution (cancel any pending request).
+ * scheduleAction('cancel') will only cancel a pending request (if any).
+ * @param {string} mode
+ * @param {number} ms
+ */
+ scheduleAction: function(mode, ms) {
+ if (this.tree.timer) {
+ clearTimeout(this.tree.timer);
+ this.tree.debug("clearTimeout(%o)", this.tree.timer);
+ }
+ this.tree.timer = null;
+ var self = this; // required for closures
+ switch (mode) {
+ case "cancel":
+ // Simply made sure that timer was cleared
+ break;
+ case "expand":
+ this.tree.timer = setTimeout(function() {
+ self.tree.debug("setTimeout: trigger expand");
+ self.setExpanded(true);
+ }, ms);
+ break;
+ case "activate":
+ this.tree.timer = setTimeout(function() {
+ self.tree.debug("setTimeout: trigger activate");
+ self.setActive(true);
+ }, ms);
+ break;
+ default:
+ $.error("Invalid mode " + mode);
+ }
+ // this.tree.debug("setTimeout(%s, %s): %s", mode, ms, this.tree.timer);
+ },
+ /**
+ *
+ * @param {boolean | PlainObject} [effects=false] animation options.
+ * @param {object} [options=null] {topNode: null, effects: ..., parent: ...} this node will remain visible in
+ * any case, even if `this` is outside the scroll pane.
+ * @returns {$.Promise}
+ */
+ scrollIntoView: function(effects, options) {
+ if (options !== undefined && _isNode(options)) {
+ throw Error(
+ "scrollIntoView() with 'topNode' option is deprecated since 2014-05-08. Use 'options.topNode' instead."
+ );
+ }
+ // The scroll parent is typically the plain tree's container.
+ // For ext-table, we choose the nearest parent that has `position: relative`
+ // and `overflow` set.
+ // (This default can be overridden by the local or global `scrollParent` option.)
+ var opts = $.extend(
+ {
+ effects:
+ effects === true
+ ? { duration: 200, queue: false }
+ : effects,
+ scrollOfs: this.tree.options.scrollOfs,
+ scrollParent: this.tree.options.scrollParent,
+ topNode: null,
+ },
+ options
+ ),
+ $scrollParent = opts.scrollParent,
+ $container = this.tree.$container,
+ overflowY = $container.css("overflow-y");
+
+ if (!$scrollParent) {
+ if (this.tree.tbody) {
+ $scrollParent = $container.scrollParent();
+ } else if (overflowY === "scroll" || overflowY === "auto") {
+ $scrollParent = $container;
+ } else {
+ // #922 plain tree in a non-fixed-sized UL scrolls inside its parent
+ $scrollParent = $container.scrollParent();
+ }
+ } else if (!$scrollParent.jquery) {
+ // Make sure we have a jQuery object
+ $scrollParent = $($scrollParent);
+ }
+ if (
+ $scrollParent[0] === document ||
+ $scrollParent[0] === document.body
+ ) {
+ // `document` may be returned by $().scrollParent(), if nothing is found,
+ // but would not work: (see #894)
+ this.debug(
+ "scrollIntoView(): normalizing scrollParent to 'window':",
+ $scrollParent[0]
+ );
+ $scrollParent = $(window);
+ }
+ // eslint-disable-next-line one-var
+ var topNodeY,
+ nodeY,
+ horzScrollbarHeight,
+ containerOffsetTop,
+ dfd = new $.Deferred(),
+ self = this,
+ nodeHeight = $(this.span).height(),
+ topOfs = opts.scrollOfs.top || 0,
+ bottomOfs = opts.scrollOfs.bottom || 0,
+ containerHeight = $scrollParent.height(),
+ scrollTop = $scrollParent.scrollTop(),
+ $animateTarget = $scrollParent,
+ isParentWindow = $scrollParent[0] === window,
+ topNode = opts.topNode || null,
+ newScrollTop = null;
+
+ // this.debug("scrollIntoView(), scrollTop=" + scrollTop, opts.scrollOfs);
+ // _assert($(this.span).is(":visible"), "scrollIntoView node is invisible"); // otherwise we cannot calc offsets
+ if (this.isRootNode() || !this.isVisible()) {
+ // We cannot calc offsets for hidden elements
+ this.info("scrollIntoView(): node is invisible.");
+ return _getResolvedPromise();
+ }
+ if (isParentWindow) {
+ nodeY = $(this.span).offset().top;
+ topNodeY =
+ topNode && topNode.span ? $(topNode.span).offset().top : 0;
+ $animateTarget = $("html,body");
+ } else {
+ _assert(
+ $scrollParent[0] !== document &&
+ $scrollParent[0] !== document.body,
+ "scrollParent should be a simple element or `window`, not document or body."
+ );
+
+ containerOffsetTop = $scrollParent.offset().top;
+ nodeY =
+ $(this.span).offset().top - containerOffsetTop + scrollTop; // relative to scroll parent
+ topNodeY = topNode
+ ? $(topNode.span).offset().top -
+ containerOffsetTop +
+ scrollTop
+ : 0;
+ horzScrollbarHeight = Math.max(
+ 0,
+ $scrollParent.innerHeight() - $scrollParent[0].clientHeight
+ );
+ containerHeight -= horzScrollbarHeight;
+ }
+
+ // this.debug(" scrollIntoView(), nodeY=" + nodeY + ", containerHeight=" + containerHeight);
+ if (nodeY < scrollTop + topOfs) {
+ // Node is above visible container area
+ newScrollTop = nodeY - topOfs;
+ // this.debug(" scrollIntoView(), UPPER newScrollTop=" + newScrollTop);
+ } else if (
+ nodeY + nodeHeight >
+ scrollTop + containerHeight - bottomOfs
+ ) {
+ newScrollTop = nodeY + nodeHeight - containerHeight + bottomOfs;
+ // this.debug(" scrollIntoView(), LOWER newScrollTop=" + newScrollTop);
+ // If a topNode was passed, make sure that it is never scrolled
+ // outside the upper border
+ if (topNode) {
+ _assert(
+ topNode.isRootNode() || topNode.isVisible(),
+ "topNode must be visible"
+ );
+ if (topNodeY < newScrollTop) {
+ newScrollTop = topNodeY - topOfs;
+ // this.debug(" scrollIntoView(), TOP newScrollTop=" + newScrollTop);
+ }
+ }
+ }
+
+ if (newScrollTop === null) {
+ dfd.resolveWith(this);
+ } else {
+ // this.debug(" scrollIntoView(), SET newScrollTop=" + newScrollTop);
+ if (opts.effects) {
+ opts.effects.complete = function() {
+ dfd.resolveWith(self);
+ };
+ $animateTarget.stop(true).animate(
+ {
+ scrollTop: newScrollTop,
+ },
+ opts.effects
+ );
+ } else {
+ $animateTarget[0].scrollTop = newScrollTop;
+ dfd.resolveWith(this);
+ }
+ }
+ return dfd.promise();
+ },
+
+ /**Activate this node.
+ *
+ * The `cell` option requires the ext-table and ext-ariagrid extensions.
+ *
+ * @param {boolean} [flag=true] pass false to deactivate
+ * @param {object} [opts] additional options. Defaults to {noEvents: false, noFocus: false, cell: null}
+ * @returns {$.Promise}
+ */
+ setActive: function(flag, opts) {
+ return this.tree._callHook("nodeSetActive", this, flag, opts);
+ },
+ /**Expand or collapse this node. Promise is resolved, when lazy loading and animations are done.
+ * @param {boolean} [flag=true] pass false to collapse
+ * @param {object} [opts] additional options. Defaults to {noAnimation: false, noEvents: false}
+ * @returns {$.Promise}
+ */
+ setExpanded: function(flag, opts) {
+ return this.tree._callHook("nodeSetExpanded", this, flag, opts);
+ },
+ /**Set keyboard focus to this node.
+ * @param {boolean} [flag=true] pass false to blur
+ * @see Fancytree#setFocus
+ */
+ setFocus: function(flag) {
+ return this.tree._callHook("nodeSetFocus", this, flag);
+ },
+ /**Select this node, i.e. check the checkbox.
+ * @param {boolean} [flag=true] pass false to deselect
+ * @param {object} [opts] additional options. Defaults to {noEvents: false, p
+ * propagateDown: null, propagateUp: null, callback: null }
+ */
+ setSelected: function(flag, opts) {
+ return this.tree._callHook("nodeSetSelected", this, flag, opts);
+ },
+ /**Mark a lazy node as 'error', 'loading', 'nodata', or 'ok'.
+ * @param {string} status 'error'|'loading'|'nodata'|'ok'
+ * @param {string} [message]
+ * @param {string} [details]
+ */
+ setStatus: function(status, message, details) {
+ return this.tree._callHook(
+ "nodeSetStatus",
+ this,
+ status,
+ message,
+ details
+ );
+ },
+ /**Rename this node.
+ * @param {string} title
+ */
+ setTitle: function(title) {
+ this.title = title;
+ this.renderTitle();
+ this.triggerModify("rename");
+ },
+ /**Sort child list by title.
+ * @param {function} [cmp] custom compare function(a, b) that returns -1, 0, or 1 (defaults to sort by title).
+ * @param {boolean} [deep=false] pass true to sort all descendant nodes
+ */
+ sortChildren: function(cmp, deep) {
+ var i,
+ l,
+ cl = this.children;
+
+ if (!cl) {
+ return;
+ }
+ cmp =
+ cmp ||
+ function(a, b) {
+ var x = a.title.toLowerCase(),
+ y = b.title.toLowerCase();
+
+ // eslint-disable-next-line no-nested-ternary
+ return x === y ? 0 : x > y ? 1 : -1;
+ };
+ cl.sort(cmp);
+ if (deep) {
+ for (i = 0, l = cl.length; i < l; i++) {
+ if (cl[i].children) {
+ cl[i].sortChildren(cmp, "$norender$");
+ }
+ }
+ }
+ if (deep !== "$norender$") {
+ this.render();
+ }
+ this.triggerModifyChild("sort");
+ },
+ /** Convert node (or whole branch) into a plain object.
+ *
+ * The result is compatible with node.addChildren().
+ *
+ * @param {boolean} [recursive=false] include child nodes
+ * @param {function} [callback] callback(dict, node) is called for every node, in order to allow modifications.
+ * Return `false` to ignore this node or `"skip"` to include this node without its children.
+ * @returns {NodeData}
+ */
+ toDict: function(recursive, callback) {
+ var i,
+ l,
+ node,
+ res,
+ dict = {},
+ self = this;
+
+ $.each(NODE_ATTRS, function(i, a) {
+ if (self[a] || self[a] === false) {
+ dict[a] = self[a];
+ }
+ });
+ if (!$.isEmptyObject(this.data)) {
+ dict.data = $.extend({}, this.data);
+ if ($.isEmptyObject(dict.data)) {
+ delete dict.data;
+ }
+ }
+ if (callback) {
+ res = callback(dict, self);
+ if (res === false) {
+ return false; // Don't include this node nor its children
+ }
+ if (res === "skip") {
+ recursive = false; // Include this node, but not the children
+ }
+ }
+ if (recursive) {
+ if ($.isArray(this.children)) {
+ dict.children = [];
+ for (i = 0, l = this.children.length; i < l; i++) {
+ node = this.children[i];
+ if (!node.isStatusNode()) {
+ res = node.toDict(true, callback);
+ if (res !== false) {
+ dict.children.push(res);
+ }
+ }
+ }
+ }
+ }
+ return dict;
+ },
+ /**
+ * Set, clear, or toggle class of node's span tag and .extraClasses.
+ *
+ * @param {string} className class name (separate multiple classes by space)
+ * @param {boolean} [flag] true/false to add/remove class. If omitted, class is toggled.
+ * @returns {boolean} true if a class was added
+ *
+ * @since 2.17
+ */
+ toggleClass: function(value, flag) {
+ var className,
+ hasClass,
+ rnotwhite = /\S+/g,
+ classNames = value.match(rnotwhite) || [],
+ i = 0,
+ wasAdded = false,
+ statusElem = this[this.tree.statusClassPropName],
+ curClasses = " " + (this.extraClasses || "") + " ";
+
+ // this.info("toggleClass('" + value + "', " + flag + ")", curClasses);
+ // Modify DOM element directly if it already exists
+ if (statusElem) {
+ $(statusElem).toggleClass(value, flag);
+ }
+ // Modify node.extraClasses to make this change persistent
+ // Toggle if flag was not passed
+ while ((className = classNames[i++])) {
+ hasClass = curClasses.indexOf(" " + className + " ") >= 0;
+ flag = flag === undefined ? !hasClass : !!flag;
+ if (flag) {
+ if (!hasClass) {
+ curClasses += className + " ";
+ wasAdded = true;
+ }
+ } else {
+ while (curClasses.indexOf(" " + className + " ") > -1) {
+ curClasses = curClasses.replace(
+ " " + className + " ",
+ " "
+ );
+ }
+ }
+ }
+ this.extraClasses = $.trim(curClasses);
+ // this.info("-> toggleClass('" + value + "', " + flag + "): '" + this.extraClasses + "'");
+ return wasAdded;
+ },
+ /** Flip expanded status. */
+ toggleExpanded: function() {
+ return this.tree._callHook("nodeToggleExpanded", this);
+ },
+ /** Flip selection status. */
+ toggleSelected: function() {
+ return this.tree._callHook("nodeToggleSelected", this);
+ },
+ toString: function() {
+ return "FancytreeNode@" + this.key + "[title='" + this.title + "']";
+ // return "";
+ },
+ /**
+ * Trigger `modifyChild` event on a parent to signal that a child was modified.
+ * @param {string} operation Type of change: 'add', 'remove', 'rename', 'move', 'data', ...
+ * @param {FancytreeNode} [childNode]
+ * @param {object} [extra]
+ */
+ triggerModifyChild: function(operation, childNode, extra) {
+ var data,
+ modifyChild = this.tree.options.modifyChild;
+
+ if (modifyChild) {
+ if (childNode && childNode.parent !== this) {
+ $.error(
+ "childNode " + childNode + " is not a child of " + this
+ );
+ }
+ data = {
+ node: this,
+ tree: this.tree,
+ operation: operation,
+ childNode: childNode || null,
+ };
+ if (extra) {
+ $.extend(data, extra);
+ }
+ modifyChild({ type: "modifyChild" }, data);
+ }
+ },
+ /**
+ * Trigger `modifyChild` event on node.parent(!).
+ * @param {string} operation Type of change: 'add', 'remove', 'rename', 'move', 'data', ...
+ * @param {object} [extra]
+ */
+ triggerModify: function(operation, extra) {
+ this.parent.triggerModifyChild(operation, this, extra);
+ },
+ /** Call fn(node) for all child nodes in hierarchical order (depth-first).Note: If you need this method, you probably should consider to review
+ * your architecture! Recursivley loading nodes is a perfect way for lazy
+ * programmers to flood the server with requests ;-)
+ *
+ * @param {function} [fn] optional callback function.
+ * Return false to stop iteration, return "skip" to skip this node and
+ * its children only.
+ * @param {boolean} [includeSelf=false]
+ * @returns {$.Promise}
+ * @since 2.4
+ */
+ visitAndLoad: function(fn, includeSelf, _recursion) {
+ var dfd,
+ res,
+ loaders,
+ node = this;
+
+ // node.debug("visitAndLoad");
+ if (fn && includeSelf === true) {
+ res = fn(node);
+ if (res === false || res === "skip") {
+ return _recursion ? res : _getResolvedPromise();
+ }
+ }
+ if (!node.children && !node.lazy) {
+ return _getResolvedPromise();
+ }
+ dfd = new $.Deferred();
+ loaders = [];
+ // node.debug("load()...");
+ node.load().done(function() {
+ // node.debug("load()... done.");
+ for (var i = 0, l = node.children.length; i < l; i++) {
+ res = node.children[i].visitAndLoad(fn, true, true);
+ if (res === false) {
+ dfd.reject();
+ break;
+ } else if (res !== "skip") {
+ loaders.push(res); // Add promise to the list
+ }
+ }
+ $.when.apply(this, loaders).then(function() {
+ dfd.resolve();
+ });
+ });
+ return dfd.promise();
+ },
+ /** Call fn(node) for all parent nodes, bottom-up, including invisible system root.` element (or `` element for ext-table).
+ * @property {jQueryObject} $div A jQuery object containing the element used to instantiate the tree widget (`widget.element`)
+ * @property {object|array} columns Recommended place to store shared column meta data. @since 2.27
+ * @property {object} data Metadata, i.e. properties that may be passed to `source` in addition to a children array.
+ * @property {object} ext Hash of all active plugin instances.
+ * @property {FancytreeNode} focusNode Currently focused node or null.
+ * @property {FancytreeNode} lastSelectedNode Used to implement selectMode 1 (single select)
+ * @property {string} nodeContainerAttrName Property name of FancytreeNode that contains the outer element of single nodes.
+ * Typically "li", but "tr" for table extension.
+ * @property {FancytreeOptions} options Current options, i.e. default options + options passed to constructor.
+ * @property {FancytreeNode} rootNode Invisible system root node.
+ * @property {string} statusClassPropName Property name of FancytreeNode that contains the element which will receive the status classes.
+ * Typically "span", but "tr" for table extension.
+ * @property {object} types Map for shared type specific meta data, used with node.type attribute. @since 2.27
+ * @property {object} viewport See ext-vieport. @since v2.31
+ * @property {object} widget Base widget instance.
+ */
+ function Fancytree(widget) {
+ this.widget = widget;
+ this.$div = widget.element;
+ this.options = widget.options;
+ if (this.options) {
+ if (this.options.lazyload !== undefined) {
+ $.error(
+ "The 'lazyload' event is deprecated since 2014-02-25. Use 'lazyLoad' (with uppercase L) instead."
+ );
+ }
+ if (this.options.loaderror !== undefined) {
+ $.error(
+ "The 'loaderror' event was renamed since 2014-07-03. Use 'loadError' (with uppercase E) instead."
+ );
+ }
+ if (this.options.fx !== undefined) {
+ $.error(
+ "The 'fx' option was replaced by 'toggleEffect' since 2014-11-30."
+ );
+ }
+ if (this.options.removeNode !== undefined) {
+ $.error(
+ "The 'removeNode' event was replaced by 'modifyChild' since 2.20 (2016-09-10)."
+ );
+ }
+ }
+ this.ext = {}; // Active extension instances
+ this.types = {};
+ this.columns = {};
+ // allow to init tree.data.foo from
+ this.data = _getElementDataAsDict(this.$div);
+ // TODO: use widget.uuid instead?
+ this._id = "" + (this.options.treeId || $.ui.fancytree._nextId++);
+ // TODO: use widget.eventNamespace instead?
+ this._ns = ".fancytree-" + this._id; // append for namespaced events
+ this.activeNode = null;
+ this.focusNode = null;
+ this._hasFocus = null;
+ this._tempCache = {};
+ this._lastMousedownNode = null;
+ this._enableUpdate = true;
+ this.lastSelectedNode = null;
+ this.systemFocusElement = null;
+ this.lastQuicksearchTerm = "";
+ this.lastQuicksearchTime = 0;
+ this.viewport = null; // ext-grid
+
+ this.statusClassPropName = "span";
+ this.ariaPropName = "li";
+ this.nodeContainerAttrName = "li";
+
+ // Remove previous markup if any
+ this.$div.find(">ul.fancytree-container").remove();
+
+ // Create a node without parent.
+ var fakeParent = { tree: this },
+ $ul;
+ this.rootNode = new FancytreeNode(fakeParent, {
+ title: "root",
+ key: "root_" + this._id,
+ children: null,
+ expanded: true,
+ });
+ this.rootNode.parent = null;
+
+ // Create root markup
+ $ul = $("
", {
+ id: "ft-id-" + this._id,
+ class: "ui-fancytree fancytree-container fancytree-plain",
+ }).appendTo(this.$div);
+ this.$container = $ul;
+ this.rootNode.ul = $ul[0];
+
+ if (this.options.debugLevel == null) {
+ this.options.debugLevel = FT.debugLevel;
+ }
+ // // Add container to the TAB chain
+ // // See http://www.w3.org/TR/wai-aria-practices/#focus_activedescendant
+ // // #577: Allow to set tabindex to "0", "-1" and ""
+ // this.$container.attr("tabindex", this.options.tabindex);
+
+ // if( this.options.rtl ) {
+ // this.$container.attr("DIR", "RTL").addClass("fancytree-rtl");
+ // // }else{
+ // // this.$container.attr("DIR", null).removeClass("fancytree-rtl");
+ // }
+ // if(this.options.aria){
+ // this.$container.attr("role", "tree");
+ // if( this.options.selectMode !== 1 ) {
+ // this.$container.attr("aria-multiselectable", true);
+ // }
+ // }
+ }
+
+ Fancytree.prototype = /** @lends Fancytree# */ {
+ /* Return a context object that can be re-used for _callHook().
+ * @param {Fancytree | FancytreeNode | EventData} obj
+ * @param {Event} originalEvent
+ * @param {Object} extra
+ * @returns {EventData}
+ */
+ _makeHookContext: function(obj, originalEvent, extra) {
+ var ctx, tree;
+ if (obj.node !== undefined) {
+ // obj is already a context object
+ if (originalEvent && obj.originalEvent !== originalEvent) {
+ $.error("invalid args");
+ }
+ ctx = obj;
+ } else if (obj.tree) {
+ // obj is a FancytreeNode
+ tree = obj.tree;
+ ctx = {
+ node: obj,
+ tree: tree,
+ widget: tree.widget,
+ options: tree.widget.options,
+ originalEvent: originalEvent,
+ typeInfo: tree.types[obj.type] || {},
+ };
+ } else if (obj.widget) {
+ // obj is a Fancytree
+ ctx = {
+ node: null,
+ tree: obj,
+ widget: obj.widget,
+ options: obj.widget.options,
+ originalEvent: originalEvent,
+ };
+ } else {
+ $.error("invalid args");
+ }
+ if (extra) {
+ $.extend(ctx, extra);
+ }
+ return ctx;
+ },
+ /* Trigger a hook function: funcName(ctx, [...]).
+ *
+ * @param {string} funcName
+ * @param {Fancytree|FancytreeNode|EventData} contextObject
+ * @param {any} [_extraArgs] optional additional arguments
+ * @returns {any}
+ */
+ _callHook: function(funcName, contextObject, _extraArgs) {
+ var ctx = this._makeHookContext(contextObject),
+ fn = this[funcName],
+ args = Array.prototype.slice.call(arguments, 2);
+ if (!$.isFunction(fn)) {
+ $.error("_callHook('" + funcName + "') is not a function");
+ }
+ args.unshift(ctx);
+ // this.debug("_hook", funcName, ctx.node && ctx.node.toString() || ctx.tree.toString(), args);
+ return fn.apply(this, args);
+ },
+ _setExpiringValue: function(key, value, ms) {
+ this._tempCache[key] = {
+ value: value,
+ expire: Date.now() + (+ms || 50),
+ };
+ },
+ _getExpiringValue: function(key) {
+ var entry = this._tempCache[key];
+ if (entry && entry.expire > Date.now()) {
+ return entry.value;
+ }
+ delete this._tempCache[key];
+ return null;
+ },
+ /* Check if this tree has extension `name` enabled.
+ *
+ * @param {string} name name of the required extension
+ */
+ _usesExtension: function(name) {
+ return $.inArray(name, this.options.extensions) >= 0;
+ },
+ /* Check if current extensions dependencies are met and throw an error if not.
+ *
+ * This method may be called inside the `treeInit` hook for custom extensions.
+ *
+ * @param {string} name name of the required extension
+ * @param {boolean} [required=true] pass `false` if the extension is optional, but we want to check for order if it is present
+ * @param {boolean} [before] `true` if `name` must be included before this, `false` otherwise (use `null` if order doesn't matter)
+ * @param {string} [message] optional error message (defaults to a descriptve error message)
+ */
+ _requireExtension: function(name, required, before, message) {
+ if (before != null) {
+ before = !!before;
+ }
+ var thisName = this._local.name,
+ extList = this.options.extensions,
+ isBefore =
+ $.inArray(name, extList) < $.inArray(thisName, extList),
+ isMissing = required && this.ext[name] == null,
+ badOrder = !isMissing && before != null && before !== isBefore;
+
+ _assert(
+ thisName && thisName !== name,
+ "invalid or same name '" + thisName + "' (require yourself?)"
+ );
+
+ if (isMissing || badOrder) {
+ if (!message) {
+ if (isMissing || required) {
+ message =
+ "'" +
+ thisName +
+ "' extension requires '" +
+ name +
+ "'";
+ if (badOrder) {
+ message +=
+ " to be registered " +
+ (before ? "before" : "after") +
+ " itself";
+ }
+ } else {
+ message =
+ "If used together, `" +
+ name +
+ "` must be registered " +
+ (before ? "before" : "after") +
+ " `" +
+ thisName +
+ "`";
+ }
+ }
+ $.error(message);
+ return false;
+ }
+ return true;
+ },
+ /** Activate node with a given key and fire focus and activate events.
+ *
+ * A previously activated node will be deactivated.
+ * If activeVisible option is set, all parents will be expanded as necessary.
+ * Pass key = false, to deactivate the current node only.
+ * @param {string} key
+ * @param {object} [opts] additional options. Defaults to {noEvents: false, noFocus: false}
+ * @returns {FancytreeNode} activated node (null, if not found)
+ */
+ activateKey: function(key, opts) {
+ var node = this.getNodeByKey(key);
+ if (node) {
+ node.setActive(true, opts);
+ } else if (this.activeNode) {
+ this.activeNode.setActive(false, opts);
+ }
+ return node;
+ },
+ /** (experimental) Add child status nodes that indicate 'More...', ....
+ * @param {boolean|object} node optional node definition. Pass `false` to remove all paging nodes.
+ * @param {string} [mode='append'] 'child'|firstChild'
+ * @since 2.15
+ */
+ addPagingNode: function(node, mode) {
+ return this.rootNode.addPagingNode(node, mode);
+ },
+ /**
+ * (experimental) Apply a modification (or navigation) operation.
+ *
+ * Valid commands:
+ * - 'moveUp', 'moveDown'
+ * - 'indent', 'outdent'
+ * - 'remove'
+ * - 'edit', 'addChild', 'addSibling': (reqires ext-edit extension)
+ * - 'cut', 'copy', 'paste': (use an internal singleton 'clipboard')
+ * - 'down', 'first', 'last', 'left', 'parent', 'right', 'up': navigate
+ *
+ * @param {string} cmd
+ * @param {FancytreeNode} [node=active_node]
+ * @param {object} [opts] Currently unused
+ *
+ * @since 2.32
+ */
+ applyCommand: function(cmd, node, opts_) {
+ var // clipboard,
+ refNode;
+ // opts = $.extend(
+ // { setActive: true, clipboard: CLIPBOARD },
+ // opts_
+ // );
+
+ node = node || this.getActiveNode();
+ // clipboard = opts.clipboard;
+
+ switch (cmd) {
+ // Sorting and indentation:
+ case "moveUp":
+ refNode = node.getPrevSibling();
+ if (refNode) {
+ node.moveTo(refNode, "before");
+ node.setActive();
+ }
+ break;
+ case "moveDown":
+ refNode = node.getNextSibling();
+ if (refNode) {
+ node.moveTo(refNode, "after");
+ node.setActive();
+ }
+ break;
+ case "indent":
+ refNode = node.getPrevSibling();
+ if (refNode) {
+ node.moveTo(refNode, "child");
+ refNode.setExpanded();
+ node.setActive();
+ }
+ break;
+ case "outdent":
+ if (!node.isTopLevel()) {
+ node.moveTo(node.getParent(), "after");
+ node.setActive();
+ }
+ break;
+ // Remove:
+ case "remove":
+ refNode = node.getPrevSibling() || node.getParent();
+ node.remove();
+ if (refNode) {
+ refNode.setActive();
+ }
+ break;
+ // Add, edit (requires ext-edit):
+ case "addChild":
+ node.editCreateNode("child", "");
+ break;
+ case "addSibling":
+ node.editCreateNode("after", "");
+ break;
+ case "rename":
+ node.editStart();
+ break;
+ // Simple clipboard simulation:
+ // case "cut":
+ // clipboard = { mode: cmd, data: node };
+ // break;
+ // case "copy":
+ // clipboard = {
+ // mode: cmd,
+ // data: node.toDict(function(d, n) {
+ // delete d.key;
+ // }),
+ // };
+ // break;
+ // case "clear":
+ // clipboard = null;
+ // break;
+ // case "paste":
+ // if (clipboard.mode === "cut") {
+ // // refNode = node.getPrevSibling();
+ // clipboard.data.moveTo(node, "child");
+ // clipboard.data.setActive();
+ // } else if (clipboard.mode === "copy") {
+ // node.addChildren(clipboard.data).setActive();
+ // }
+ // break;
+ // Navigation commands:
+ case "down":
+ case "first":
+ case "last":
+ case "left":
+ case "parent":
+ case "right":
+ case "up":
+ return node.navigate(cmd);
+ default:
+ $.error("Unhandled command: '" + cmd + "'");
+ }
+ },
+ /** (experimental) Modify existing data model.
+ *
+ * @param {Array} patchList array of [key, NodePatch] arrays
+ * @returns {$.Promise} resolved, when all patches have been applied
+ * @see TreePatch
+ */
+ applyPatch: function(patchList) {
+ var dfd,
+ i,
+ p2,
+ key,
+ patch,
+ node,
+ patchCount = patchList.length,
+ deferredList = [];
+
+ for (i = 0; i < patchCount; i++) {
+ p2 = patchList[i];
+ _assert(
+ p2.length === 2,
+ "patchList must be an array of length-2-arrays"
+ );
+ key = p2[0];
+ patch = p2[1];
+ node = key === null ? this.rootNode : this.getNodeByKey(key);
+ if (node) {
+ dfd = new $.Deferred();
+ deferredList.push(dfd);
+ node.applyPatch(patch).always(_makeResolveFunc(dfd, node));
+ } else {
+ this.warn("could not find node with key '" + key + "'");
+ }
+ }
+ // Return a promise that is resolved, when ALL patches were applied
+ return $.when.apply($, deferredList).promise();
+ },
+ /* TODO: implement in dnd extension
+ cancelDrag: function() {
+ var dd = $.ui.ddmanager.current;
+ if(dd){
+ dd.cancel();
+ }
+ },
+ */
+ /** Remove all nodes.
+ * @since 2.14
+ */
+ clear: function(source) {
+ this._callHook("treeClear", this);
+ },
+ /** Return the number of nodes.
+ * @returns {integer}
+ */
+ count: function() {
+ return this.rootNode.countChildren();
+ },
+ /** Write to browser console if debugLevel >= 4 (prepending tree name)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ debug: function(msg) {
+ if (this.options.debugLevel >= 4) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("log", arguments);
+ }
+ },
+ /** Destroy this widget, restore previous markup and cleanup resources.
+ *
+ * @since 2.34
+ */
+ destroy: function() {
+ this.widget.destroy();
+ },
+ /** Enable (or disable) the tree control.
+ *
+ * @param {boolean} [flag=true] pass false to disable
+ * @since 2.30
+ */
+ enable: function(flag) {
+ if (flag === false) {
+ this.widget.disable();
+ } else {
+ this.widget.enable();
+ }
+ },
+ /** Temporarily suppress rendering to improve performance on bulk-updates.
+ *
+ * @param {boolean} flag
+ * @returns {boolean} previous status
+ * @since 2.19
+ */
+ enableUpdate: function(flag) {
+ flag = flag !== false;
+ if (!!this._enableUpdate === !!flag) {
+ return flag;
+ }
+ this._enableUpdate = flag;
+ if (flag) {
+ this.debug("enableUpdate(true): redraw "); //, this._dirtyRoots);
+ this._callHook("treeStructureChanged", this, "enableUpdate");
+ this.render();
+ } else {
+ // this._dirtyRoots = null;
+ this.debug("enableUpdate(false)...");
+ }
+ return !flag; // return previous value
+ },
+ /** Write error to browser console if debugLevel >= 1 (prepending tree info)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ error: function(msg) {
+ if (this.options.debugLevel >= 1) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("error", arguments);
+ }
+ },
+ /** Expand (or collapse) all parent nodes.
+ *
+ * This convenience method uses `tree.visit()` and `tree.setExpanded()`
+ * internally.
+ *
+ * @param {boolean} [flag=true] pass false to collapse
+ * @param {object} [opts] passed to setExpanded()
+ * @since 2.30
+ */
+ expandAll: function(flag, opts) {
+ var prev = this.enableUpdate(false);
+
+ flag = flag !== false;
+ this.visit(function(node) {
+ if (
+ node.hasChildren() !== false &&
+ node.isExpanded() !== flag
+ ) {
+ node.setExpanded(flag, opts);
+ }
+ });
+ this.enableUpdate(prev);
+ },
+ /**Find all nodes that matches condition.
+ *
+ * @param {string | function(node)} match title string to search for, or a
+ * callback function that returns `true` if a node is matched.
+ * @returns {FancytreeNode[]} array of nodes (may be empty)
+ * @see FancytreeNode#findAll
+ * @since 2.12
+ */
+ findAll: function(match) {
+ return this.rootNode.findAll(match);
+ },
+ /**Find first node that matches condition.
+ *
+ * @param {string | function(node)} match title string to search for, or a
+ * callback function that returns `true` if a node is matched.
+ * @returns {FancytreeNode} matching node or null
+ * @see FancytreeNode#findFirst
+ * @since 2.12
+ */
+ findFirst: function(match) {
+ return this.rootNode.findFirst(match);
+ },
+ /** Find the next visible node that starts with `match`, starting at `startNode`
+ * and wrap-around at the end.
+ *
+ * @param {string|function} match
+ * @param {FancytreeNode} [startNode] defaults to first node
+ * @returns {FancytreeNode} matching node or null
+ */
+ findNextNode: function(match, startNode) {
+ //, visibleOnly) {
+ var res = null,
+ firstNode = this.getFirstChild();
+
+ match =
+ typeof match === "string"
+ ? _makeNodeTitleStartMatcher(match)
+ : match;
+ startNode = startNode || firstNode;
+
+ function _checkNode(n) {
+ // console.log("_check " + n)
+ if (match(n)) {
+ res = n;
+ }
+ if (res || n === startNode) {
+ return false;
+ }
+ }
+ this.visitRows(_checkNode, {
+ start: startNode,
+ includeSelf: false,
+ });
+ // Wrap around search
+ if (!res && startNode !== firstNode) {
+ this.visitRows(_checkNode, {
+ start: firstNode,
+ includeSelf: true,
+ });
+ }
+ return res;
+ },
+ /** Find a node relative to another node.
+ *
+ * @param {FancytreeNode} node
+ * @param {string|number} where 'down', 'first', 'last', 'left', 'parent', 'right', or 'up'.
+ * (Alternatively the keyCode that would normally trigger this move,
+ * e.g. `$.ui.keyCode.LEFT` = 'left'.
+ * @param {boolean} [includeHidden=false] Not yet implemented
+ * @returns {FancytreeNode|null}
+ * @since v2.31
+ */
+ findRelatedNode: function(node, where, includeHidden) {
+ var res = null,
+ KC = $.ui.keyCode;
+
+ switch (where) {
+ case "parent":
+ case KC.BACKSPACE:
+ if (node.parent && node.parent.parent) {
+ res = node.parent;
+ }
+ break;
+ case "first":
+ case KC.HOME:
+ // First visible node
+ this.visit(function(n) {
+ if (n.isVisible()) {
+ res = n;
+ return false;
+ }
+ });
+ break;
+ case "last":
+ case KC.END:
+ this.visit(function(n) {
+ // last visible node
+ if (n.isVisible()) {
+ res = n;
+ }
+ });
+ break;
+ case "left":
+ case KC.LEFT:
+ if (node.expanded) {
+ node.setExpanded(false);
+ } else if (node.parent && node.parent.parent) {
+ res = node.parent;
+ }
+ break;
+ case "right":
+ case KC.RIGHT:
+ if (!node.expanded && (node.children || node.lazy)) {
+ node.setExpanded();
+ res = node;
+ } else if (node.children && node.children.length) {
+ res = node.children[0];
+ }
+ break;
+ case "up":
+ case KC.UP:
+ this.visitRows(
+ function(n) {
+ res = n;
+ return false;
+ },
+ { start: node, reverse: true, includeSelf: false }
+ );
+ break;
+ case "down":
+ case KC.DOWN:
+ this.visitRows(
+ function(n) {
+ res = n;
+ return false;
+ },
+ { start: node, includeSelf: false }
+ );
+ break;
+ default:
+ this.tree.warn("Unknown relation '" + where + "'.");
+ }
+ return res;
+ },
+ // TODO: fromDict
+ /**
+ * Generate INPUT elements that can be submitted with html forms.
+ *
+ * In selectMode 3 only the topmost selected nodes are considered, unless
+ * `opts.stopOnParents: false` is passed.
+ *
+ * @example
+ * // Generate input elements for active and selected nodes
+ * tree.generateFormElements();
+ * // Generate input elements selected nodes, using a custom `name` attribute
+ * tree.generateFormElements("cust_sel", false);
+ * // Generate input elements using a custom filter
+ * tree.generateFormElements(true, true, { filter: function(node) {
+ * return node.isSelected() && node.data.yes;
+ * }});
+ *
+ * @param {boolean | string} [selected=true] Pass false to disable, pass a string to override the field name (default: 'ft_ID[]')
+ * @param {boolean | string} [active=true] Pass false to disable, pass a string to override the field name (default: 'ft_ID_active')
+ * @param {object} [opts] default { filter: null, stopOnParents: true }
+ */
+ generateFormElements: function(selected, active, opts) {
+ opts = opts || {};
+
+ var nodeList,
+ selectedName =
+ typeof selected === "string"
+ ? selected
+ : "ft_" + this._id + "[]",
+ activeName =
+ typeof active === "string"
+ ? active
+ : "ft_" + this._id + "_active",
+ id = "fancytree_result_" + this._id,
+ $result = $("#" + id),
+ stopOnParents =
+ this.options.selectMode === 3 &&
+ opts.stopOnParents !== false;
+
+ if ($result.length) {
+ $result.empty();
+ } else {
+ $result = $("", {
+ id: id,
+ })
+ .hide()
+ .insertAfter(this.$container);
+ }
+ if (active !== false && this.activeNode) {
+ $result.append(
+ $("
", {
+ type: "radio",
+ name: activeName,
+ value: this.activeNode.key,
+ checked: true,
+ })
+ );
+ }
+ function _appender(node) {
+ $result.append(
+ $("
", {
+ type: "checkbox",
+ name: selectedName,
+ value: node.key,
+ checked: true,
+ })
+ );
+ }
+ if (opts.filter) {
+ this.visit(function(node) {
+ var res = opts.filter(node);
+ if (res === "skip") {
+ return res;
+ }
+ if (res !== false) {
+ _appender(node);
+ }
+ });
+ } else if (selected !== false) {
+ nodeList = this.getSelectedNodes(stopOnParents);
+ $.each(nodeList, function(idx, node) {
+ _appender(node);
+ });
+ }
+ },
+ /**
+ * Return the currently active node or null.
+ * @returns {FancytreeNode}
+ */
+ getActiveNode: function() {
+ return this.activeNode;
+ },
+ /** Return the first top level node if any (not the invisible root node).
+ * @returns {FancytreeNode | null}
+ */
+ getFirstChild: function() {
+ return this.rootNode.getFirstChild();
+ },
+ /**
+ * Return node that has keyboard focus or null.
+ * @returns {FancytreeNode}
+ */
+ getFocusNode: function() {
+ return this.focusNode;
+ },
+ /**
+ * Return current option value.
+ * (Note: this is the preferred variant of `$().fancytree("option", "KEY")`)
+ *
+ * @param {string} name option name (may contain '.')
+ * @returns {any}
+ */
+ getOption: function(optionName) {
+ return this.widget.option(optionName);
+ },
+ /**
+ * Return node with a given key or null if not found.
+ *
+ * @param {string} key
+ * @param {FancytreeNode} [searchRoot] only search below this node
+ * @returns {FancytreeNode | null}
+ */
+ getNodeByKey: function(key, searchRoot) {
+ // Search the DOM by element ID (assuming this is faster than traversing all nodes).
+ var el, match;
+ // TODO: use tree.keyMap if available
+ // TODO: check opts.generateIds === true
+ if (!searchRoot) {
+ el = document.getElementById(this.options.idPrefix + key);
+ if (el) {
+ return el.ftnode ? el.ftnode : null;
+ }
+ }
+ // Not found in the DOM, but still may be in an unrendered part of tree
+ searchRoot = searchRoot || this.rootNode;
+ match = null;
+ key = "" + key; // Convert to string (#1005)
+ searchRoot.visit(function(node) {
+ if (node.key === key) {
+ match = node;
+ return false; // Stop iteration
+ }
+ }, true);
+ return match;
+ },
+ /** Return the invisible system root node.
+ * @returns {FancytreeNode}
+ */
+ getRootNode: function() {
+ return this.rootNode;
+ },
+ /**
+ * Return an array of selected nodes.
+ *
+ * Note: you cannot send this result via Ajax directly. Instead the
+ * node object need to be converted to plain objects, for example
+ * by using `$.map()` and `node.toDict()`.
+ * @param {boolean} [stopOnParents=false] only return the topmost selected
+ * node (useful with selectMode 3)
+ * @returns {FancytreeNode[]}
+ */
+ getSelectedNodes: function(stopOnParents) {
+ return this.rootNode.getSelectedNodes(stopOnParents);
+ },
+ /** Return true if the tree control has keyboard focus
+ * @returns {boolean}
+ */
+ hasFocus: function() {
+ // var ae = document.activeElement,
+ // hasFocus = !!(
+ // ae && $(ae).closest(".fancytree-container").length
+ // );
+
+ // if (hasFocus !== !!this._hasFocus) {
+ // this.warn(
+ // "hasFocus(): fix inconsistent container state, now: " +
+ // hasFocus
+ // );
+ // this._hasFocus = hasFocus;
+ // this.$container.toggleClass("fancytree-treefocus", hasFocus);
+ // }
+ // return hasFocus;
+ return !!this._hasFocus;
+ },
+ /** Write to browser console if debugLevel >= 3 (prepending tree name)
+ * @param {*} msg string or object or array of such
+ */
+ info: function(msg) {
+ if (this.options.debugLevel >= 3) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("info", arguments);
+ }
+ },
+ /** Return true if any node is currently beeing loaded, i.e. a Ajax request is pending.
+ * @returns {boolean}
+ * @since 2.32
+ */
+ isLoading: function() {
+ var res = false;
+
+ this.rootNode.visit(function(n) {
+ // also visit rootNode
+ if (n._isLoading || n._requestId) {
+ res = true;
+ return false;
+ }
+ }, true);
+ return res;
+ },
+ /*
+ TODO: isInitializing: function() {
+ return ( this.phase=="init" || this.phase=="postInit" );
+ },
+ TODO: isReloading: function() {
+ return ( this.phase=="init" || this.phase=="postInit" ) && this.options.persist && this.persistence.cookiesFound;
+ },
+ TODO: isUserEvent: function() {
+ return ( this.phase=="userEvent" );
+ },
+ */
+
+ /**
+ * Make sure that a node with a given ID is loaded, by traversing - and
+ * loading - its parents. This method is meant for lazy hierarchies.
+ * A callback is executed for every node as we go.
+ * @example
+ * // Resolve using node.key:
+ * tree.loadKeyPath("/_3/_23/_26/_27", function(node, status){
+ * if(status === "loaded") {
+ * console.log("loaded intermediate node " + node);
+ * }else if(status === "ok") {
+ * node.activate();
+ * }
+ * });
+ * // Use deferred promise:
+ * tree.loadKeyPath("/_3/_23/_26/_27").progress(function(data){
+ * if(data.status === "loaded") {
+ * console.log("loaded intermediate node " + data.node);
+ * }else if(data.status === "ok") {
+ * node.activate();
+ * }
+ * }).done(function(){
+ * ...
+ * });
+ * // Custom path segment resolver:
+ * tree.loadKeyPath("/321/431/21/2", {
+ * matchKey: function(node, key){
+ * return node.data.refKey === key;
+ * },
+ * callback: function(node, status){
+ * if(status === "loaded") {
+ * console.log("loaded intermediate node " + node);
+ * }else if(status === "ok") {
+ * node.activate();
+ * }
+ * }
+ * });
+ * @param {string | string[]} keyPathList one or more key paths (e.g. '/3/2_1/7')
+ * @param {function | object} optsOrCallback callback(node, status) is called for every visited node ('loading', 'loaded', 'ok', 'error').
+ * Pass an object to define custom key matchers for the path segments: {callback: function, matchKey: function}.
+ * @returns {$.Promise}
+ */
+ loadKeyPath: function(keyPathList, optsOrCallback) {
+ var callback,
+ i,
+ path,
+ self = this,
+ dfd = new $.Deferred(),
+ parent = this.getRootNode(),
+ sep = this.options.keyPathSeparator,
+ pathSegList = [],
+ opts = $.extend({}, optsOrCallback);
+
+ // Prepare options
+ if (typeof optsOrCallback === "function") {
+ callback = optsOrCallback;
+ } else if (optsOrCallback && optsOrCallback.callback) {
+ callback = optsOrCallback.callback;
+ }
+ opts.callback = function(ctx, node, status) {
+ if (callback) {
+ callback.call(ctx, node, status);
+ }
+ dfd.notifyWith(ctx, [{ node: node, status: status }]);
+ };
+ if (opts.matchKey == null) {
+ opts.matchKey = function(node, key) {
+ return node.key === key;
+ };
+ }
+ // Convert array of path strings to array of segment arrays
+ if (!$.isArray(keyPathList)) {
+ keyPathList = [keyPathList];
+ }
+ for (i = 0; i < keyPathList.length; i++) {
+ path = keyPathList[i];
+ // strip leading slash
+ if (path.charAt(0) === sep) {
+ path = path.substr(1);
+ }
+ // segListMap[path] = { parent: parent, segList: path.split(sep) };
+ pathSegList.push(path.split(sep));
+ // targetList.push({ parent: parent, segList: path.split(sep)/* , path: path*/});
+ }
+ // The timeout forces async behavior always (even if nodes are all loaded)
+ // This way a potential progress() event will fire.
+ setTimeout(function() {
+ self._loadKeyPathImpl(dfd, opts, parent, pathSegList).done(
+ function() {
+ dfd.resolve();
+ }
+ );
+ }, 0);
+ return dfd.promise();
+ },
+ /*
+ * Resolve a list of paths, relative to one parent node.
+ */
+ _loadKeyPathImpl: function(dfd, opts, parent, pathSegList) {
+ var deferredList,
+ i,
+ key,
+ node,
+ nodeKey,
+ remain,
+ remainMap,
+ tmpParent,
+ segList,
+ subDfd,
+ self = this;
+
+ function __findChild(parent, key) {
+ // console.log("__findChild", key, parent);
+ var i,
+ l,
+ cl = parent.children;
+
+ if (cl) {
+ for (i = 0, l = cl.length; i < l; i++) {
+ if (opts.matchKey(cl[i], key)) {
+ return cl[i];
+ }
+ }
+ }
+ return null;
+ }
+
+ // console.log("_loadKeyPathImpl, parent=", parent, ", pathSegList=", pathSegList);
+
+ // Pass 1:
+ // Handle all path segments for nodes that are already loaded.
+ // Collect distinct top-most lazy nodes in a map.
+ // Note that we can use node.key to de-dupe entries, even if a custom matcher would
+ // look for other node attributes.
+ // map[node.key] => {node: node, pathList: [list of remaining rest-paths]}
+ remainMap = {};
+
+ for (i = 0; i < pathSegList.length; i++) {
+ segList = pathSegList[i];
+ // target = targetList[i];
+
+ // Traverse and pop path segments (i.e. keys), until we hit a lazy, unloaded node
+ tmpParent = parent;
+ while (segList.length) {
+ key = segList.shift();
+ node = __findChild(tmpParent, key);
+ if (!node) {
+ this.warn(
+ "loadKeyPath: key not found: " +
+ key +
+ " (parent: " +
+ tmpParent +
+ ")"
+ );
+ opts.callback(this, key, "error");
+ break;
+ } else if (segList.length === 0) {
+ opts.callback(this, node, "ok");
+ break;
+ } else if (!node.lazy || node.hasChildren() !== undefined) {
+ opts.callback(this, node, "loaded");
+ tmpParent = node;
+ } else {
+ opts.callback(this, node, "loaded");
+ key = node.key; //target.segList.join(sep);
+ if (remainMap[key]) {
+ remainMap[key].pathSegList.push(segList);
+ } else {
+ remainMap[key] = {
+ parent: node,
+ pathSegList: [segList],
+ };
+ }
+ break;
+ }
+ }
+ }
+ // console.log("_loadKeyPathImpl AFTER pass 1, remainMap=", remainMap);
+
+ // Now load all lazy nodes and continue iteration for remaining paths
+ deferredList = [];
+
+ // Avoid jshint warning 'Don't make functions within a loop.':
+ function __lazyload(dfd, parent, pathSegList) {
+ // console.log("__lazyload", parent, "pathSegList=", pathSegList);
+ opts.callback(self, parent, "loading");
+ parent
+ .load()
+ .done(function() {
+ self._loadKeyPathImpl
+ .call(self, dfd, opts, parent, pathSegList)
+ .always(_makeResolveFunc(dfd, self));
+ })
+ .fail(function(errMsg) {
+ self.warn("loadKeyPath: error loading lazy " + parent);
+ opts.callback(self, node, "error");
+ dfd.rejectWith(self);
+ });
+ }
+ // remainMap contains parent nodes, each with a list of relative sub-paths.
+ // We start loading all of them now, and pass the the list to each loader.
+ for (nodeKey in remainMap) {
+ if (remainMap.hasOwnProperty(nodeKey)) {
+ remain = remainMap[nodeKey];
+ // console.log("for(): remain=", remain, "remainMap=", remainMap);
+ // key = remain.segList.shift();
+ // node = __findChild(remain.parent, key);
+ // if (node == null) { // #576
+ // // Issue #576, refactored for v2.27:
+ // // The root cause was, that sometimes the wrong parent was used here
+ // // to find the next segment.
+ // // Falling back to getNodeByKey() was a hack that no longer works if a custom
+ // // matcher is used, because we cannot assume that a single segment-key is unique
+ // // throughout the tree.
+ // self.error("loadKeyPath: error loading child by key '" + key + "' (parent: " + target.parent + ")", target);
+ // // node = self.getNodeByKey(key);
+ // continue;
+ // }
+ subDfd = new $.Deferred();
+ deferredList.push(subDfd);
+ __lazyload(subDfd, remain.parent, remain.pathSegList);
+ }
+ }
+ // Return a promise that is resolved, when ALL paths were loaded
+ return $.when.apply($, deferredList).promise();
+ },
+ /** Re-fire beforeActivate, activate, and (optional) focus events.
+ * Calling this method in the `init` event, will activate the node that
+ * was marked 'active' in the source data, and optionally set the keyboard
+ * focus.
+ * @param [setFocus=false]
+ */
+ reactivate: function(setFocus) {
+ var res,
+ node = this.activeNode;
+
+ if (!node) {
+ return _getResolvedPromise();
+ }
+ this.activeNode = null; // Force re-activating
+ res = node.setActive(true, { noFocus: true });
+ if (setFocus) {
+ node.setFocus();
+ }
+ return res;
+ },
+ /** Reload tree from source and return a promise.
+ * @param [source] optional new source (defaults to initial source data)
+ * @returns {$.Promise}
+ */
+ reload: function(source) {
+ this._callHook("treeClear", this);
+ return this._callHook("treeLoad", this, source);
+ },
+ /**Render tree (i.e. create DOM elements for all top-level nodes).
+ * @param {boolean} [force=false] create DOM elemnts, even if parent is collapsed
+ * @param {boolean} [deep=false]
+ */
+ render: function(force, deep) {
+ return this.rootNode.render(force, deep);
+ },
+ /**(De)select all nodes.
+ * @param {boolean} [flag=true]
+ * @since 2.28
+ */
+ selectAll: function(flag) {
+ this.visit(function(node) {
+ node.setSelected(flag);
+ });
+ },
+ // TODO: selectKey: function(key, select)
+ // TODO: serializeArray: function(stopOnParents)
+ /**
+ * @param {boolean} [flag=true]
+ */
+ setFocus: function(flag) {
+ return this._callHook("treeSetFocus", this, flag);
+ },
+ /**
+ * Set current option value.
+ * (Note: this is the preferred variant of `$().fancytree("option", "KEY", VALUE)`)
+ * @param {string} name option name (may contain '.')
+ * @param {any} new value
+ */
+ setOption: function(optionName, value) {
+ return this.widget.option(optionName, value);
+ },
+ /**
+ * Call console.time() when in debug mode (verbose >= 4).
+ *
+ * @param {string} label
+ */
+ debugTime: function(label) {
+ if (this.options.debugLevel >= 4) {
+ window.console.time(this + " - " + label);
+ }
+ },
+ /**
+ * Call console.timeEnd() when in debug mode (verbose >= 4).
+ *
+ * @param {string} label
+ */
+ debugTimeEnd: function(label) {
+ if (this.options.debugLevel >= 4) {
+ window.console.timeEnd(this + " - " + label);
+ }
+ },
+ /**
+ * Return all nodes as nested list of {@link NodeData}.
+ *
+ * @param {boolean} [includeRoot=false] Returns the hidden system root node (and its children)
+ * @param {function} [callback] callback(dict, node) is called for every node, in order to allow modifications.
+ * Return `false` to ignore this node or "skip" to include this node without its children.
+ * @returns {Array | object}
+ * @see FancytreeNode#toDict
+ */
+ toDict: function(includeRoot, callback) {
+ var res = this.rootNode.toDict(true, callback);
+ return includeRoot ? res : res.children;
+ },
+ /* Implicitly called for string conversions.
+ * @returns {string}
+ */
+ toString: function() {
+ return "Fancytree@" + this._id;
+ // return "
";
+ },
+ /* _trigger a widget event with additional node ctx.
+ * @see EventData
+ */
+ _triggerNodeEvent: function(type, node, originalEvent, extra) {
+ // this.debug("_trigger(" + type + "): '" + ctx.node.title + "'", ctx);
+ var ctx = this._makeHookContext(node, originalEvent, extra),
+ res = this.widget._trigger(type, originalEvent, ctx);
+ if (res !== false && ctx.result !== undefined) {
+ return ctx.result;
+ }
+ return res;
+ },
+ /* _trigger a widget event with additional tree data. */
+ _triggerTreeEvent: function(type, originalEvent, extra) {
+ // this.debug("_trigger(" + type + ")", ctx);
+ var ctx = this._makeHookContext(this, originalEvent, extra),
+ res = this.widget._trigger(type, originalEvent, ctx);
+
+ if (res !== false && ctx.result !== undefined) {
+ return ctx.result;
+ }
+ return res;
+ },
+ /** Call fn(node) for all nodes in hierarchical order (depth-first).
+ *
+ * @param {function} fn the callback function.
+ * Return false to stop iteration, return "skip" to skip this node and children only.
+ * @returns {boolean} false, if the iterator was stopped.
+ */
+ visit: function(fn) {
+ return this.rootNode.visit(fn, false);
+ },
+ /** Call fn(node) for all nodes in vertical order, top down (or bottom up). jumps to the top
+ // if(event.target.localName === "a" && event.target.className === "fancytree-title"){
+ // event.preventDefault();
+ // }
+ // TODO: return promise?
+ },
+ /** Collapse all other children of same parent.
+ *
+ * @param {EventData} ctx
+ * @param {object} callOpts
+ */
+ nodeCollapseSiblings: function(ctx, callOpts) {
+ // TODO: return promise?
+ var ac,
+ i,
+ l,
+ node = ctx.node;
+
+ if (node.parent) {
+ ac = node.parent.children;
+ for (i = 0, l = ac.length; i < l; i++) {
+ if (ac[i] !== node && ac[i].expanded) {
+ this._callHook(
+ "nodeSetExpanded",
+ ac[i],
+ false,
+ callOpts
+ );
+ }
+ }
+ }
+ },
+ /** Default handling for mouse douleclick events.
+ * @param {EventData} ctx
+ */
+ nodeDblclick: function(ctx) {
+ // TODO: return promise?
+ if (
+ ctx.targetType === "title" &&
+ ctx.options.clickFolderMode === 4
+ ) {
+ // this.nodeSetFocus(ctx);
+ // this._callHook("nodeSetActive", ctx, true);
+ this._callHook("nodeToggleExpanded", ctx);
+ }
+ // TODO: prevent text selection on dblclicks
+ if (ctx.targetType === "title") {
+ ctx.originalEvent.preventDefault();
+ }
+ },
+ /** Default handling for mouse keydown events.
+ *
+ * NOTE: this may be called with node == null if tree (but no node) has focus.
+ * @param {EventData} ctx
+ */
+ nodeKeydown: function(ctx) {
+ // TODO: return promise?
+ var matchNode,
+ stamp,
+ _res,
+ focusNode,
+ event = ctx.originalEvent,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ which = event.which,
+ // #909: Use event.key, to get unicode characters.
+ // We can't use `/\w/.test(key)`, because that would
+ // only detect plain ascii alpha-numerics. But we still need
+ // to ignore modifier-only, whitespace, cursor-keys, etc.
+ key = event.key || String.fromCharCode(which),
+ specialModifiers = !!(
+ event.altKey ||
+ event.ctrlKey ||
+ event.metaKey
+ ),
+ isAlnum =
+ !MODIFIERS[which] &&
+ !SPECIAL_KEYCODES[which] &&
+ !specialModifiers,
+ $target = $(event.target),
+ handled = true,
+ activate = !(event.ctrlKey || !opts.autoActivate);
+
+ // (node || FT).debug("ftnode.nodeKeydown(" + event.type + "): ftnode:" + this + ", charCode:" + event.charCode + ", keyCode: " + event.keyCode + ", which: " + event.which);
+ // FT.debug( "eventToString(): " + FT.eventToString(event) + ", key='" + key + "', isAlnum: " + isAlnum );
+
+ // Set focus to active (or first node) if no other node has the focus yet
+ if (!node) {
+ focusNode = this.getActiveNode() || this.getFirstChild();
+ if (focusNode) {
+ focusNode.setFocus();
+ node = ctx.node = this.focusNode;
+ node.debug("Keydown force focus on active node");
+ }
+ }
+
+ if (
+ opts.quicksearch &&
+ isAlnum &&
+ !$target.is(":input:enabled")
+ ) {
+ // Allow to search for longer streaks if typed in quickly
+ stamp = Date.now();
+ if (stamp - tree.lastQuicksearchTime > 500) {
+ tree.lastQuicksearchTerm = "";
+ }
+ tree.lastQuicksearchTime = stamp;
+ tree.lastQuicksearchTerm += key;
+ // tree.debug("quicksearch find", tree.lastQuicksearchTerm);
+ matchNode = tree.findNextNode(
+ tree.lastQuicksearchTerm,
+ tree.getActiveNode()
+ );
+ if (matchNode) {
+ matchNode.setActive();
+ }
+ event.preventDefault();
+ return;
+ }
+ switch (FT.eventToString(event)) {
+ case "+":
+ case "=": // 187: '+' @ Chrome, Safari
+ tree.nodeSetExpanded(ctx, true);
+ break;
+ case "-":
+ tree.nodeSetExpanded(ctx, false);
+ break;
+ case "space":
+ if (node.isPagingNode()) {
+ tree._triggerNodeEvent("clickPaging", ctx, event);
+ } else if (
+ FT.evalOption("checkbox", node, node, opts, false)
+ ) {
+ // #768
+ tree.nodeToggleSelected(ctx);
+ } else {
+ tree.nodeSetActive(ctx, true);
+ }
+ break;
+ case "return":
+ tree.nodeSetActive(ctx, true);
+ break;
+ case "home":
+ case "end":
+ case "backspace":
+ case "left":
+ case "right":
+ case "up":
+ case "down":
+ _res = node.navigate(event.which, activate);
+ break;
+ default:
+ handled = false;
+ }
+ if (handled) {
+ event.preventDefault();
+ }
+ },
+
+ // /** Default handling for mouse keypress events. */
+ // nodeKeypress: function(ctx) {
+ // var event = ctx.originalEvent;
+ // },
+
+ // /** Trigger lazyLoad event (async). */
+ // nodeLazyLoad: function(ctx) {
+ // var node = ctx.node;
+ // if(this._triggerNodeEvent())
+ // },
+ /** Load child nodes (async).
+ *
+ * @param {EventData} ctx
+ * @param {object[]|object|string|$.Promise|function} source
+ * @returns {$.Promise} The deferred will be resolved as soon as the (ajax)
+ * data was rendered.
+ */
+ nodeLoadChildren: function(ctx, source) {
+ var ajax,
+ delay,
+ ajaxDfd = null,
+ resultDfd,
+ isAsync = true,
+ tree = ctx.tree,
+ node = ctx.node,
+ nodePrevParent = node.parent,
+ tag = "nodeLoadChildren",
+ requestId = Date.now();
+
+ // `source` is a callback: use the returned result instead:
+ if ($.isFunction(source)) {
+ source = source.call(tree, { type: "source" }, ctx);
+ _assert(
+ !$.isFunction(source),
+ "source callback must not return another function"
+ );
+ }
+ // `source` is already a promise:
+ if ($.isFunction(source.then)) {
+ // _assert($.isFunction(source.always), "Expected jQuery?");
+ ajaxDfd = source;
+ } else if (source.url) {
+ // `source` is an Ajax options object
+ ajax = $.extend({}, ctx.options.ajax, source);
+ if (ajax.debugDelay) {
+ // Simulate a slow server
+ delay = ajax.debugDelay;
+ delete ajax.debugDelay; // remove debug option
+ if ($.isArray(delay)) {
+ // random delay range [min..max]
+ delay =
+ delay[0] +
+ Math.random() * (delay[1] - delay[0]);
+ }
+ node.warn(
+ "nodeLoadChildren waiting debugDelay " +
+ Math.round(delay) +
+ " ms ..."
+ );
+ ajaxDfd = $.Deferred(function(ajaxDfd) {
+ setTimeout(function() {
+ $.ajax(ajax)
+ .done(function() {
+ ajaxDfd.resolveWith(this, arguments);
+ })
+ .fail(function() {
+ ajaxDfd.rejectWith(this, arguments);
+ });
+ }, delay);
+ });
+ } else {
+ ajaxDfd = $.ajax(ajax);
+ }
+ } else if ($.isPlainObject(source) || $.isArray(source)) {
+ // `source` is already a constant dict or list, but we convert
+ // to a thenable for unified processing.
+ // 2020-01-03: refactored.
+ // `ajaxDfd = $.when(source)` would do the trick, but the returned
+ // promise will resolve async, which broke some tests and
+ // would probably also break current implementations out there.
+ // So we mock-up a thenable that resolves synchronously:
+ ajaxDfd = {
+ then: function(resolve, reject) {
+ resolve(source, null, null);
+ },
+ };
+ isAsync = false;
+ } else {
+ $.error("Invalid source type: " + source);
+ }
+
+ // Check for overlapping requests
+ if (node._requestId) {
+ node.warn(
+ "Recursive load request #" +
+ requestId +
+ " while #" +
+ node._requestId +
+ " is pending."
+ );
+ node._requestId = requestId;
+ // node.debug("Send load request #" + requestId);
+ }
+
+ if (isAsync) {
+ tree.debugTime(tag);
+ tree.nodeSetStatus(ctx, "loading");
+ }
+
+ // The async Ajax request has now started...
+ // Defer the deferred:
+ // we want to be able to reject invalid responses, even if
+ // the raw HTTP Ajax XHR resolved as Ok.
+ // We use the ajaxDfd.then() syntax here, which is compatible with
+ // jQuery and ECMA6.
+ // However resultDfd is a jQuery deferred, which is currently the
+ // expected result type of nodeLoadChildren()
+ resultDfd = new $.Deferred();
+ ajaxDfd.then(
+ function(data, textStatus, jqXHR) {
+ // ajaxDfd was resolved, but we reject or resolve resultDfd
+ // depending on the response data
+ var errorObj, res;
+
+ if (
+ (source.dataType === "json" ||
+ source.dataType === "jsonp") &&
+ typeof data === "string"
+ ) {
+ $.error(
+ "Ajax request returned a string (did you get the JSON dataType wrong?)."
+ );
+ }
+ if (node._requestId && node._requestId > requestId) {
+ // The expected request time stamp is later than `requestId`
+ // (which was kept as as closure variable to this handler function)
+ // node.warn("Ignored load response for obsolete request #" + requestId + " (expected #" + node._requestId + ")");
+ resultDfd.rejectWith(this, [
+ RECURSIVE_REQUEST_ERROR,
+ ]);
+ return;
+ // } else {
+ // node.debug("Response returned for load request #" + requestId);
+ }
+ if (node.parent === null && nodePrevParent !== null) {
+ resultDfd.rejectWith(this, [
+ INVALID_REQUEST_TARGET_ERROR,
+ ]);
+ return;
+ }
+ // Allow to adjust the received response data in the `postProcess` event.
+ if (ctx.options.postProcess) {
+ // The handler may either
+ // - modify `ctx.response` in-place (and leave `ctx.result` undefined)
+ // => res = undefined
+ // - return a replacement in `ctx.result`
+ // => res =
+ // If res contains an `error` property, an error status is displayed
+ try {
+ res = tree._triggerNodeEvent(
+ "postProcess",
+ ctx,
+ ctx.originalEvent,
+ {
+ response: data,
+ error: null,
+ dataType: source.dataType,
+ }
+ );
+ } catch (e) {
+ res = {
+ error: e,
+ message: "" + e,
+ details: "postProcess failed",
+ };
+ }
+ if (res.error) {
+ // Either postProcess failed with an exception, or the returned
+ // result object has an 'error' property attached:
+ errorObj = $.isPlainObject(res.error)
+ ? res.error
+ : { message: res.error };
+ errorObj = tree._makeHookContext(
+ node,
+ null,
+ errorObj
+ );
+ resultDfd.rejectWith(this, [errorObj]);
+ return;
+ }
+ if (
+ $.isArray(res) ||
+ ($.isPlainObject(res) &&
+ $.isArray(res.children))
+ ) {
+ // Use `ctx.result` if valid
+ // (otherwise use existing data, which may have been modified in-place)
+ data = res;
+ }
+ } else if (
+ data &&
+ data.hasOwnProperty("d") &&
+ ctx.options.enableAspx
+ ) {
+ // Process ASPX WebMethod JSON object inside "d" property
+ // (only if no postProcess event was defined)
+ if (ctx.options.enableAspx === 42) {
+ tree.warn(
+ "The default for enableAspx will change to `false` in the fututure. " +
+ "Pass `enableAspx: true` or implement postProcess to silence this warning."
+ );
+ }
+ data =
+ typeof data.d === "string"
+ ? $.parseJSON(data.d)
+ : data.d;
+ }
+ resultDfd.resolveWith(this, [data]);
+ },
+ function(jqXHR, textStatus, errorThrown) {
+ // ajaxDfd was rejected, so we reject resultDfd as well
+ var errorObj = tree._makeHookContext(node, null, {
+ error: jqXHR,
+ args: Array.prototype.slice.call(arguments),
+ message: errorThrown,
+ details: jqXHR.status + ": " + errorThrown,
+ });
+ resultDfd.rejectWith(this, [errorObj]);
+ }
+ );
+
+ // The async Ajax request has now started.
+ // resultDfd will be resolved/rejected after the response arrived,
+ // was postProcessed, and checked.
+ // Now we implement the UI update and add the data to the tree.
+ // We also return this promise to the caller.
+ resultDfd
+ .done(function(data) {
+ tree.nodeSetStatus(ctx, "ok");
+ var children, metaData, noDataRes;
+
+ if ($.isPlainObject(data)) {
+ // We got {foo: 'abc', children: [...]}
+ // Copy extra properties to tree.data.foo
+ _assert(
+ node.isRootNode(),
+ "source may only be an object for root nodes (expecting an array of child objects otherwise)"
+ );
+ _assert(
+ $.isArray(data.children),
+ "if an object is passed as source, it must contain a 'children' array (all other properties are added to 'tree.data')"
+ );
+ metaData = data;
+ children = data.children;
+ delete metaData.children;
+ // Copy some attributes to tree.data
+ $.each(TREE_ATTRS, function(i, attr) {
+ if (metaData[attr] !== undefined) {
+ tree[attr] = metaData[attr];
+ delete metaData[attr];
+ }
+ });
+ // Copy all other attributes to tree.data.NAME
+ $.extend(tree.data, metaData);
+ } else {
+ children = data;
+ }
+ _assert(
+ $.isArray(children),
+ "expected array of children"
+ );
+ node._setChildren(children);
+
+ if (tree.options.nodata && children.length === 0) {
+ if ($.isFunction(tree.options.nodata)) {
+ noDataRes = tree.options.nodata.call(
+ tree,
+ { type: "nodata" },
+ ctx
+ );
+ } else if (
+ tree.options.nodata === true &&
+ node.isRootNode()
+ ) {
+ noDataRes = tree.options.strings.noData;
+ } else if (
+ typeof tree.options.nodata === "string" &&
+ node.isRootNode()
+ ) {
+ noDataRes = tree.options.nodata;
+ }
+ if (noDataRes) {
+ node.setStatus("nodata", noDataRes);
+ }
+ }
+ // trigger fancytreeloadchildren
+ tree._triggerNodeEvent("loadChildren", node);
+ })
+ .fail(function(error) {
+ var ctxErr;
+
+ if (error === RECURSIVE_REQUEST_ERROR) {
+ node.warn(
+ "Ignored response for obsolete load request #" +
+ requestId +
+ " (expected #" +
+ node._requestId +
+ ")"
+ );
+ return;
+ } else if (error === INVALID_REQUEST_TARGET_ERROR) {
+ node.warn(
+ "Lazy parent node was removed while loading: discarding response."
+ );
+ return;
+ } else if (error.node && error.error && error.message) {
+ // error is already a context object
+ ctxErr = error;
+ } else {
+ ctxErr = tree._makeHookContext(node, null, {
+ error: error, // it can be jqXHR or any custom error
+ args: Array.prototype.slice.call(arguments),
+ message: error
+ ? error.message || error.toString()
+ : "",
+ });
+ if (ctxErr.message === "[object Object]") {
+ ctxErr.message = "";
+ }
+ }
+ node.warn(
+ "Load children failed (" + ctxErr.message + ")",
+ ctxErr
+ );
+ if (
+ tree._triggerNodeEvent(
+ "loadError",
+ ctxErr,
+ null
+ ) !== false
+ ) {
+ tree.nodeSetStatus(
+ ctx,
+ "error",
+ ctxErr.message,
+ ctxErr.details
+ );
+ }
+ })
+ .always(function() {
+ node._requestId = null;
+ if (isAsync) {
+ tree.debugTimeEnd(tag);
+ }
+ });
+
+ return resultDfd.promise();
+ },
+ /** [Not Implemented] */
+ nodeLoadKeyPath: function(ctx, keyPathList) {
+ // TODO: implement and improve
+ // http://code.google.com/p/dynatree/issues/detail?id=222
+ },
+ /**
+ * Remove a single direct child of ctx.node.
+ * @param {EventData} ctx
+ * @param {FancytreeNode} childNode dircect child of ctx.node
+ */
+ nodeRemoveChild: function(ctx, childNode) {
+ var idx,
+ node = ctx.node,
+ // opts = ctx.options,
+ subCtx = $.extend({}, ctx, { node: childNode }),
+ children = node.children;
+
+ // FT.debug("nodeRemoveChild()", node.toString(), childNode.toString());
+
+ if (children.length === 1) {
+ _assert(childNode === children[0], "invalid single child");
+ return this.nodeRemoveChildren(ctx);
+ }
+ if (
+ this.activeNode &&
+ (childNode === this.activeNode ||
+ this.activeNode.isDescendantOf(childNode))
+ ) {
+ this.activeNode.setActive(false); // TODO: don't fire events
+ }
+ if (
+ this.focusNode &&
+ (childNode === this.focusNode ||
+ this.focusNode.isDescendantOf(childNode))
+ ) {
+ this.focusNode = null;
+ }
+ // TODO: persist must take care to clear select and expand cookies
+ this.nodeRemoveMarkup(subCtx);
+ this.nodeRemoveChildren(subCtx);
+ idx = $.inArray(childNode, children);
+ _assert(idx >= 0, "invalid child");
+ // Notify listeners
+ node.triggerModifyChild("remove", childNode);
+ // Unlink to support GC
+ childNode.visit(function(n) {
+ n.parent = null;
+ }, true);
+ this._callHook("treeRegisterNode", this, false, childNode);
+ // remove from child list
+ children.splice(idx, 1);
+ },
+ /**Remove HTML markup for all descendents of ctx.node.
+ * @param {EventData} ctx
+ */
+ nodeRemoveChildMarkup: function(ctx) {
+ var node = ctx.node;
+
+ // FT.debug("nodeRemoveChildMarkup()", node.toString());
+ // TODO: Unlink attr.ftnode to support GC
+ if (node.ul) {
+ if (node.isRootNode()) {
+ $(node.ul).empty();
+ } else {
+ $(node.ul).remove();
+ node.ul = null;
+ }
+ node.visit(function(n) {
+ n.li = n.ul = null;
+ });
+ }
+ },
+ /**Remove all descendants of ctx.node.
+ * @param {EventData} ctx
+ */
+ nodeRemoveChildren: function(ctx) {
+ var //subCtx,
+ tree = ctx.tree,
+ node = ctx.node,
+ children = node.children;
+ // opts = ctx.options;
+
+ // FT.debug("nodeRemoveChildren()", node.toString());
+ if (!children) {
+ return;
+ }
+ if (this.activeNode && this.activeNode.isDescendantOf(node)) {
+ this.activeNode.setActive(false); // TODO: don't fire events
+ }
+ if (this.focusNode && this.focusNode.isDescendantOf(node)) {
+ this.focusNode = null;
+ }
+ // TODO: persist must take care to clear select and expand cookies
+ this.nodeRemoveChildMarkup(ctx);
+ // Unlink children to support GC
+ // TODO: also delete this.children (not possible using visit())
+ // subCtx = $.extend({}, ctx);
+ node.triggerModifyChild("remove", null);
+ node.visit(function(n) {
+ n.parent = null;
+ tree._callHook("treeRegisterNode", tree, false, n);
+ });
+ if (node.lazy) {
+ // 'undefined' would be interpreted as 'not yet loaded' for lazy nodes
+ node.children = [];
+ } else {
+ node.children = null;
+ }
+ if (!node.isRootNode()) {
+ node.expanded = false; // #449, #459
+ }
+ this.nodeRenderStatus(ctx);
+ },
+ /**Remove HTML markup for ctx.node and all its descendents.
+ * @param {EventData} ctx
+ */
+ nodeRemoveMarkup: function(ctx) {
+ var node = ctx.node;
+ // FT.debug("nodeRemoveMarkup()", node.toString());
+ // TODO: Unlink attr.ftnode to support GC
+ if (node.li) {
+ $(node.li).remove();
+ node.li = null;
+ }
+ this.nodeRemoveChildMarkup(ctx);
+ },
+ /**
+ * Create `.. ..
+ *
+ * Node 1
+ *
+ * // only present if node has children
+ * child1 ...
+ * child2 ...
+ *
+ *
+ * ```
+ *
+ * @param {EventData} ctx
+ * @param {boolean} [force=false] re-render, even if html markup was already created
+ * @param {boolean} [deep=false] also render all descendants, even if parent is collapsed
+ * @param {boolean} [collapsed=false] force root node to be collapsed, so we can apply animated expand later
+ */
+ nodeRender: function(ctx, force, deep, collapsed, _recursive) {
+ /* This method must take care of all cases where the current data mode
+ * (i.e. node hierarchy) does not match the current markup.
+ *
+ * - node was not yet rendered:
+ * create markup
+ * - node was rendered: exit fast
+ * - children have been added
+ * - children have been removed
+ */
+ var childLI,
+ childNode1,
+ childNode2,
+ i,
+ l,
+ next,
+ subCtx,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ aria = opts.aria,
+ firstTime = false,
+ parent = node.parent,
+ isRootNode = !parent,
+ children = node.children,
+ successorLi = null;
+ // FT.debug("nodeRender(" + !!force + ", " + !!deep + ")", node.toString());
+
+ if (tree._enableUpdate === false) {
+ // tree.debug("no render", tree._enableUpdate);
+ return;
+ }
+ if (!isRootNode && !parent.ul) {
+ // Calling node.collapse on a deep, unrendered node
+ return;
+ }
+ _assert(isRootNode || parent.ul, "parent UL must exist");
+
+ // Render the node
+ if (!isRootNode) {
+ // Discard markup on force-mode, or if it is not linked to parent
+ if (
+ node.li &&
+ (force || node.li.parentNode !== node.parent.ul)
+ ) {
+ if (node.li.parentNode === node.parent.ul) {
+ // #486: store following node, so we can insert the new markup there later
+ successorLi = node.li.nextSibling;
+ } else {
+ // May happen, when a top-level node was dropped over another
+ this.debug(
+ "Unlinking " +
+ node +
+ " (must be child of " +
+ node.parent +
+ ")"
+ );
+ }
+ // this.debug("nodeRemoveMarkup...");
+ this.nodeRemoveMarkup(ctx);
+ }
+ // Create (expander, checkbox, icon, and title)
+ this.nodeRenderTitle(ctx);
+
+ // Allow tweaking and binding, after node was created for the first time
+ if (opts.createNode) {
+ opts.createNode.call(
+ tree,
+ { type: "createNode" },
+ ctx
+ );
+ }
+ }
+ // Allow tweaking after node state was rendered
+ if (opts.renderNode) {
+ opts.renderNode.call(tree, { type: "renderNode" }, ctx);
+ }
+ }
+
+ // Visit child nodes
+ if (children) {
+ if (isRootNode || node.expanded || deep === true) {
+ // Create a UL to hold the children
+ if (!node.ul) {
+ node.ul = document.createElement("ul");
+ if (
+ (collapsed === true && !_recursive) ||
+ !node.expanded
+ ) {
+ // hide top UL, so we can use an animation to show it later
+ node.ul.style.display = "none";
+ }
+ if (aria) {
+ $(node.ul).attr("role", "group");
+ }
+ if (node.li) {
+ // issue #67
+ node.li.appendChild(node.ul);
+ } else {
+ node.tree.$div.append(node.ul);
+ }
+ }
+ // Add child markup
+ for (i = 0, l = children.length; i < l; i++) {
+ subCtx = $.extend({}, ctx, { node: children[i] });
+ this.nodeRender(subCtx, force, deep, false, true);
+ }
+ // Remove if nodes have moved to another parent
+ childLI = node.ul.firstChild;
+ while (childLI) {
+ childNode2 = childLI.ftnode;
+ if (childNode2 && childNode2.parent !== node) {
+ node.debug(
+ "_fixParent: remove missing " + childNode2,
+ childLI
+ );
+ next = childLI.nextSibling;
+ childLI.parentNode.removeChild(childLI);
+ childLI = next;
+ } else {
+ childLI = childLI.nextSibling;
+ }
+ }
+ // Make sure, that order matches node.children order.
+ childLI = node.ul.firstChild;
+ for (i = 0, l = children.length - 1; i < l; i++) {
+ childNode1 = children[i];
+ childNode2 = childLI.ftnode;
+ if (childNode1 === childNode2) {
+ childLI = childLI.nextSibling;
+ } else {
+ // node.debug("_fixOrder: mismatch at index " + i + ": " + childNode1 + " != " + childNode2);
+ node.ul.insertBefore(
+ childNode1.li,
+ childNode2.li
+ );
+ }
+ }
+ }
+ } else {
+ // No children: remove markup if any
+ if (node.ul) {
+ // alert("remove child markup for " + node);
+ this.warn("remove child markup for " + node);
+ this.nodeRemoveChildMarkup(ctx);
+ }
+ }
+ if (!isRootNode) {
+ // Update element classes according to node state
+ // this.nodeRenderStatus(ctx);
+ // Finally add the whole structure to the DOM, so the browser can render
+ if (firstTime) {
+ // #486: successorLi is set, if we re-rendered (i.e. discarded)
+ // existing markup, which we want to insert at the same position.
+ // (null is equivalent to append)
+ // parent.ul.appendChild(node.li);
+ parent.ul.insertBefore(node.li, successorLi);
+ }
+ }
+ },
+ /** Create HTML inside the node's outer `` (i.e. expander, checkbox,
+ * icon, and title).
+ *
+ * nodeRenderStatus() is implied.
+ * @param {EventData} ctx
+ * @param {string} [title] optinal new title
+ */
+ nodeRenderTitle: function(ctx, title) {
+ // set node connector images, links and text
+ var checkbox,
+ className,
+ icon,
+ nodeTitle,
+ role,
+ tabindex,
+ tooltip,
+ iconTooltip,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ aria = opts.aria,
+ level = node.getLevel(),
+ ares = [];
+
+ if (title !== undefined) {
+ node.title = title;
+ }
+ if (!node.span || tree._enableUpdate === false) {
+ // Silently bail out if node was not rendered yet, assuming
+ // node.render() will be called as the node becomes visible
+ return;
+ }
+ // Connector (expanded, expandable or simple)
+ role =
+ aria && node.hasChildren() !== false
+ ? " role='button'"
+ : "";
+ if (level < opts.minExpandLevel) {
+ if (!node.lazy) {
+ node.expanded = true;
+ }
+ if (level > 1) {
+ ares.push(
+ "" +
+ FT.escapeHtml(icon.text) +
+ " "
+ );
+ } else if (icon.html) {
+ ares.push(
+ "" +
+ icon.html +
+ " "
+ );
+ } else {
+ // standard icon: theme css will take care of this
+ ares.push(
+ "" +
+ (opts.escapeTitles
+ ? FT.escapeHtml(node.title)
+ : node.title) +
+ " ";
+ }
+ ares.push(nodeTitle);
+ // Note: this will trigger focusout, if node had the focus
+ //$(node.span).html(ares.join("")); // it will cleanup the jQuery data currently associated with SPAN (if any), but it executes more slowly
+ node.span.innerHTML = ares.join("");
+ // Update CSS classes
+ this.nodeRenderStatus(ctx);
+ if (opts.enhanceTitle) {
+ ctx.$title = $(">span.fancytree-title", node.span);
+ nodeTitle =
+ opts.enhanceTitle.call(
+ tree,
+ { type: "enhanceTitle" },
+ ctx
+ ) || "";
+ }
+ },
+ /** Update element classes according to node state.
+ * @param {EventData} ctx
+ */
+ nodeRenderStatus: function(ctx) {
+ // Set classes for current status
+ var $ariaElem,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ // nodeContainer = node[tree.nodeContainerAttrName],
+ hasChildren = node.hasChildren(),
+ isLastSib = node.isLastSibling(),
+ aria = opts.aria,
+ cn = opts._classNames,
+ cnList = [],
+ statusElem = node[tree.statusClassPropName];
+
+ if (!statusElem || tree._enableUpdate === false) {
+ // if this function is called for an unrendered node, ignore it (will be updated on nect render anyway)
+ return;
+ }
+ if (aria) {
+ $ariaElem = $(node.tr || node.li);
+ }
+ // Build a list of class names that we will add to the node
+ cnList.push(cn.node);
+ if (tree.activeNode === node) {
+ cnList.push(cn.active);
+ // $(">span.fancytree-title", statusElem).attr("tabindex", "0");
+ // tree.$container.removeAttr("tabindex");
+ // }else{
+ // $(">span.fancytree-title", statusElem).removeAttr("tabindex");
+ // tree.$container.attr("tabindex", "0");
+ }
+ if (tree.focusNode === node) {
+ cnList.push(cn.focused);
+ }
+ if (node.expanded) {
+ cnList.push(cn.expanded);
+ }
+ if (aria) {
+ if (hasChildren === false) {
+ $ariaElem.removeAttr("aria-expanded");
+ } else {
+ $ariaElem.attr("aria-expanded", Boolean(node.expanded));
+ }
+ }
+ if (node.folder) {
+ cnList.push(cn.folder);
+ }
+ if (hasChildren !== false) {
+ cnList.push(cn.hasChildren);
+ }
+ // TODO: required?
+ if (isLastSib) {
+ cnList.push(cn.lastsib);
+ }
+ if (node.lazy && node.children == null) {
+ cnList.push(cn.lazy);
+ }
+ if (node.partload) {
+ cnList.push(cn.partload);
+ }
+ if (node.partsel) {
+ cnList.push(cn.partsel);
+ }
+ if (FT.evalOption("unselectable", node, node, opts, false)) {
+ cnList.push(cn.unselectable);
+ }
+ if (node._isLoading) {
+ cnList.push(cn.loading);
+ }
+ if (node._error) {
+ cnList.push(cn.error);
+ }
+ if (node.statusNodeType) {
+ cnList.push(cn.statusNodePrefix + node.statusNodeType);
+ }
+ if (node.selected) {
+ cnList.push(cn.selected);
+ if (aria) {
+ $ariaElem.attr("aria-selected", true);
+ }
+ } else if (aria) {
+ $ariaElem.attr("aria-selected", false);
+ }
+ if (node.extraClasses) {
+ cnList.push(node.extraClasses);
+ }
+ // IE6 doesn't correctly evaluate multiple class names,
+ // so we create combined class names that can be used in the CSS
+ if (hasChildren === false) {
+ cnList.push(
+ cn.combinedExpanderPrefix + "n" + (isLastSib ? "l" : "")
+ );
+ } else {
+ cnList.push(
+ cn.combinedExpanderPrefix +
+ (node.expanded ? "e" : "c") +
+ (node.lazy && node.children == null ? "d" : "") +
+ (isLastSib ? "l" : "")
+ );
+ }
+ cnList.push(
+ cn.combinedIconPrefix +
+ (node.expanded ? "e" : "c") +
+ (node.folder ? "f" : "")
+ );
+ // node.span.className = cnList.join(" ");
+ statusElem.className = cnList.join(" ");
+
+ // TODO: we should not set this in the tag also, if we set it here:
+ // Maybe most (all) of the classes should be set in LI instead of SPAN?
+ if (node.li) {
+ // #719: we have to consider that there may be already other classes:
+ $(node.li).toggleClass(cn.lastsib, isLastSib);
+ }
+ },
+ /** Activate node.
+ * flag defaults to true.
+ * If flag is true, the node is activated (must be a synchronous operation)
+ * If flag is false, the node is deactivated (must be a synchronous operation)
+ * @param {EventData} ctx
+ * @param {boolean} [flag=true]
+ * @param {object} [opts] additional options. Defaults to {noEvents: false, noFocus: false}
+ * @returns {$.Promise}
+ */
+ nodeSetActive: function(ctx, flag, callOpts) {
+ // Handle user click / [space] / [enter], according to clickFolderMode.
+ callOpts = callOpts || {};
+ var subCtx,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ noEvents = callOpts.noEvents === true,
+ noFocus = callOpts.noFocus === true,
+ scroll = callOpts.scrollIntoView !== false,
+ isActive = node === tree.activeNode;
+
+ // flag defaults to true
+ flag = flag !== false;
+ // node.debug("nodeSetActive", flag);
+
+ if (isActive === flag) {
+ // Nothing to do
+ return _getResolvedPromise(node);
+ } else if (
+ flag &&
+ !noEvents &&
+ this._triggerNodeEvent(
+ "beforeActivate",
+ node,
+ ctx.originalEvent
+ ) === false
+ ) {
+ // Callback returned false
+ return _getRejectedPromise(node, ["rejected"]);
+ }
+ if (flag) {
+ if (tree.activeNode) {
+ _assert(
+ tree.activeNode !== node,
+ "node was active (inconsistency)"
+ );
+ subCtx = $.extend({}, ctx, { node: tree.activeNode });
+ tree.nodeSetActive(subCtx, false);
+ _assert(
+ tree.activeNode === null,
+ "deactivate was out of sync?"
+ );
+ }
+
+ if (opts.activeVisible) {
+ // If no focus is set (noFocus: true) and there is no focused node, this node is made visible.
+ // scroll = noFocus && tree.focusNode == null;
+ // #863: scroll by default (unless `scrollIntoView: false` was passed)
+ node.makeVisible({ scrollIntoView: scroll });
+ }
+ tree.activeNode = node;
+ tree.nodeRenderStatus(ctx);
+ if (!noFocus) {
+ tree.nodeSetFocus(ctx);
+ }
+ if (!noEvents) {
+ tree._triggerNodeEvent(
+ "activate",
+ node,
+ ctx.originalEvent
+ );
+ }
+ } else {
+ _assert(
+ tree.activeNode === node,
+ "node was not active (inconsistency)"
+ );
+ tree.activeNode = null;
+ this.nodeRenderStatus(ctx);
+ if (!noEvents) {
+ ctx.tree._triggerNodeEvent(
+ "deactivate",
+ node,
+ ctx.originalEvent
+ );
+ }
+ }
+ return _getResolvedPromise(node);
+ },
+ /** Expand or collapse node, return Deferred.promise.
+ *
+ * @param {EventData} ctx
+ * @param {boolean} [flag=true]
+ * @param {object} [opts] additional options. Defaults to `{noAnimation: false, noEvents: false}`
+ * @returns {$.Promise} The deferred will be resolved as soon as the (lazy)
+ * data was retrieved, rendered, and the expand animation finished.
+ */
+ nodeSetExpanded: function(ctx, flag, callOpts) {
+ callOpts = callOpts || {};
+ var _afterLoad,
+ dfd,
+ i,
+ l,
+ parents,
+ prevAC,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ noAnimation = callOpts.noAnimation === true,
+ noEvents = callOpts.noEvents === true;
+
+ // flag defaults to true
+ flag = flag !== false;
+
+ // node.debug("nodeSetExpanded(" + flag + ")");
+
+ if ((node.expanded && flag) || (!node.expanded && !flag)) {
+ // Nothing to do
+ // node.debug("nodeSetExpanded(" + flag + "): nothing to do");
+ return _getResolvedPromise(node);
+ } else if (flag && !node.lazy && !node.hasChildren()) {
+ // Prevent expanding of empty nodes
+ // return _getRejectedPromise(node, ["empty"]);
+ return _getResolvedPromise(node);
+ } else if (!flag && node.getLevel() < opts.minExpandLevel) {
+ // Prevent collapsing locked levels
+ return _getRejectedPromise(node, ["locked"]);
+ } else if (
+ !noEvents &&
+ this._triggerNodeEvent(
+ "beforeExpand",
+ node,
+ ctx.originalEvent
+ ) === false
+ ) {
+ // Callback returned false
+ return _getRejectedPromise(node, ["rejected"]);
+ }
+ // If this node inside a collpased node, no animation and scrolling is needed
+ if (!noAnimation && !node.isVisible()) {
+ noAnimation = callOpts.noAnimation = true;
+ }
+
+ dfd = new $.Deferred();
+
+ // Auto-collapse mode: collapse all siblings
+ if (flag && !node.expanded && opts.autoCollapse) {
+ parents = node.getParentList(false, true);
+ prevAC = opts.autoCollapse;
+ try {
+ opts.autoCollapse = false;
+ for (i = 0, l = parents.length; i < l; i++) {
+ // TODO: should return promise?
+ this._callHook(
+ "nodeCollapseSiblings",
+ parents[i],
+ callOpts
+ );
+ }
+ } finally {
+ opts.autoCollapse = prevAC;
+ }
+ }
+ // Trigger expand/collapse after expanding
+ dfd.done(function() {
+ var lastChild = node.getLastChild();
+
+ if (
+ flag &&
+ opts.autoScroll &&
+ !noAnimation &&
+ lastChild &&
+ tree._enableUpdate
+ ) {
+ // Scroll down to last child, but keep current node visible
+ lastChild
+ .scrollIntoView(true, { topNode: node })
+ .always(function() {
+ if (!noEvents) {
+ ctx.tree._triggerNodeEvent(
+ flag ? "expand" : "collapse",
+ ctx
+ );
+ }
+ });
+ } else {
+ if (!noEvents) {
+ ctx.tree._triggerNodeEvent(
+ flag ? "expand" : "collapse",
+ ctx
+ );
+ }
+ }
+ });
+ // vvv Code below is executed after loading finished:
+ _afterLoad = function(callback) {
+ var cn = opts._classNames,
+ isVisible,
+ isExpanded,
+ effect = opts.toggleEffect;
+
+ node.expanded = flag;
+ tree._callHook(
+ "treeStructureChanged",
+ ctx,
+ flag ? "expand" : "collapse"
+ );
+ // Create required markup, but make sure the top UL is hidden, so we
+ // can animate later
+ tree._callHook("nodeRender", ctx, false, false, true);
+
+ // Hide children, if node is collapsed
+ if (node.ul) {
+ isVisible = node.ul.style.display !== "none";
+ isExpanded = !!node.expanded;
+ if (isVisible === isExpanded) {
+ node.warn(
+ "nodeSetExpanded: UL.style.display already set"
+ );
+ } else if (!effect || noAnimation) {
+ node.ul.style.display =
+ node.expanded || !parent ? "" : "none";
+ } else {
+ // The UI toggle() effect works with the ext-wide extension,
+ // while jQuery.animate() has problems when the title span
+ // has position: absolute.
+ // Since jQuery UI 1.12, the blind effect requires the parent
+ // element to have 'position: relative'.
+ // See #716, #717
+ $(node.li).addClass(cn.animating); // #717
+
+ if ($.isFunction($(node.ul)[effect.effect])) {
+ // tree.debug( "use jquery." + effect.effect + " method" );
+ $(node.ul)[effect.effect]({
+ duration: effect.duration,
+ always: function() {
+ // node.debug("fancytree-animating end: " + node.li.className);
+ $(this).removeClass(cn.animating); // #716
+ $(node.li).removeClass(cn.animating); // #717
+ callback();
+ },
+ });
+ } else {
+ // The UI toggle() effect works with the ext-wide extension,
+ // while jQuery.animate() has problems when the title span
+ // has positon: absolute.
+ // Since jQuery UI 1.12, the blind effect requires the parent
+ // element to have 'position: relative'.
+ // See #716, #717
+ // tree.debug("use specified effect (" + effect.effect + ") with the jqueryui.toggle method");
+
+ // try to stop an animation that might be already in progress
+ $(node.ul).stop(true, true); //< does not work after resetLazy has been called for a node whose animation wasn't complete and effect was "blind"
+
+ // dirty fix to remove a defunct animation (effect: "blind") after resetLazy has been called
+ $(node.ul)
+ .parent()
+ .find(".ui-effects-placeholder")
+ .remove();
+
+ $(node.ul).toggle(
+ effect.effect,
+ effect.options,
+ effect.duration,
+ function() {
+ // node.debug("fancytree-animating end: " + node.li.className);
+ $(this).removeClass(cn.animating); // #716
+ $(node.li).removeClass(cn.animating); // #717
+ callback();
+ }
+ );
+ }
+ return;
+ }
+ }
+ callback();
+ };
+ // ^^^ Code above is executed after loading finshed.
+
+ // Load lazy nodes, if any. Then continue with _afterLoad()
+ if (flag && node.lazy && node.hasChildren() === undefined) {
+ // node.debug("nodeSetExpanded: load start...");
+ node.load()
+ .done(function() {
+ // node.debug("nodeSetExpanded: load done");
+ if (dfd.notifyWith) {
+ // requires jQuery 1.6+
+ dfd.notifyWith(node, ["loaded"]);
+ }
+ _afterLoad(function() {
+ dfd.resolveWith(node);
+ });
+ })
+ .fail(function(errMsg) {
+ _afterLoad(function() {
+ dfd.rejectWith(node, [
+ "load failed (" + errMsg + ")",
+ ]);
+ });
+ });
+ /*
+ var source = tree._triggerNodeEvent("lazyLoad", node, ctx.originalEvent);
+ _assert(typeof source !== "boolean", "lazyLoad event must return source in data.result");
+ node.debug("nodeSetExpanded: load start...");
+ this._callHook("nodeLoadChildren", ctx, source).done(function(){
+ node.debug("nodeSetExpanded: load done");
+ if(dfd.notifyWith){ // requires jQuery 1.6+
+ dfd.notifyWith(node, ["loaded"]);
+ }
+ _afterLoad.call(tree);
+ }).fail(function(errMsg){
+ dfd.rejectWith(node, ["load failed (" + errMsg + ")"]);
+ });
+ */
+ } else {
+ _afterLoad(function() {
+ dfd.resolveWith(node);
+ });
+ }
+ // node.debug("nodeSetExpanded: returns");
+ return dfd.promise();
+ },
+ /** Focus or blur this node.
+ * @param {EventData} ctx
+ * @param {boolean} [flag=true]
+ */
+ nodeSetFocus: function(ctx, flag) {
+ // ctx.node.debug("nodeSetFocus(" + flag + ")");
+ var ctx2,
+ tree = ctx.tree,
+ node = ctx.node,
+ opts = tree.options,
+ // et = ctx.originalEvent && ctx.originalEvent.type,
+ isInput = ctx.originalEvent
+ ? $(ctx.originalEvent.target).is(":input")
+ : false;
+
+ flag = flag !== false;
+
+ // (node || tree).debug("nodeSetFocus(" + flag + "), event: " + et + ", isInput: "+ isInput);
+ // Blur previous node if any
+ if (tree.focusNode) {
+ if (tree.focusNode === node && flag) {
+ // node.debug("nodeSetFocus(" + flag + "): nothing to do");
+ return;
+ }
+ ctx2 = $.extend({}, ctx, { node: tree.focusNode });
+ tree.focusNode = null;
+ this._triggerNodeEvent("blur", ctx2);
+ this._callHook("nodeRenderStatus", ctx2);
+ }
+ // Set focus to container and node
+ if (flag) {
+ if (!this.hasFocus()) {
+ node.debug("nodeSetFocus: forcing container focus");
+ this._callHook("treeSetFocus", ctx, true, {
+ calledByNode: true,
+ });
+ }
+ node.makeVisible({ scrollIntoView: false });
+ tree.focusNode = node;
+ if (opts.titlesTabbable) {
+ if (!isInput) {
+ // #621
+ $(node.span)
+ .find(".fancytree-title")
+ .focus();
+ }
+ }
+ if (opts.aria) {
+ // Set active descendant to node's span ID (create one, if needed)
+ $(tree.$container).attr(
+ "aria-activedescendant",
+ $(node.tr || node.li)
+ .uniqueId()
+ .attr("id")
+ );
+ // "ftal_" + opts.idPrefix + node.key);
+ }
+ // $(node.span).find(".fancytree-title").focus();
+ this._triggerNodeEvent("focus", ctx);
+
+ // determine if we have focus on or inside tree container
+ var hasFancytreeFocus =
+ document.activeElement === tree.$container.get(0) ||
+ $(document.activeElement, tree.$container).length >= 1;
+
+ if (!hasFancytreeFocus) {
+ // We cannot set KB focus to a node, so use the tree container
+ // #563, #570: IE scrolls on every call to .focus(), if the container
+ // is partially outside the viewport. So do it only, when absolutely
+ // necessary.
+ $(tree.$container).focus();
+ }
+
+ // if( opts.autoActivate ){
+ // tree.nodeSetActive(ctx, true);
+ // }
+ if (opts.autoScroll) {
+ node.scrollIntoView();
+ }
+ this._callHook("nodeRenderStatus", ctx);
+ }
+ },
+ /** (De)Select node, return new status (sync).
+ *
+ * @param {EventData} ctx
+ * @param {boolean} [flag=true]
+ * @param {object} [opts] additional options. Defaults to {noEvents: false,
+ * propagateDown: null, propagateUp: null,
+ * callback: null,
+ * }
+ * @returns {boolean} previous status
+ */
+ nodeSetSelected: function(ctx, flag, callOpts) {
+ callOpts = callOpts || {};
+ var node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ noEvents = callOpts.noEvents === true,
+ parent = node.parent;
+
+ // flag defaults to true
+ flag = flag !== false;
+
+ // node.debug("nodeSetSelected(" + flag + ")", ctx);
+
+ // Cannot (de)select unselectable nodes directly (only by propagation or
+ // by setting the `.selected` property)
+ if (FT.evalOption("unselectable", node, node, opts, false)) {
+ return;
+ }
+
+ // Remember the user's intent, in case down -> up propagation prevents
+ // applying it to node.selected
+ node._lastSelectIntent = flag; // Confusing use of '!'
+
+ // Nothing to do?
+ if (!!node.selected === flag) {
+ if (opts.selectMode === 3 && node.partsel && !flag) {
+ // If propagation prevented selecting this node last time, we still
+ // want to allow to apply setSelected(false) now
+ } else {
+ return flag;
+ }
+ }
+
+ if (
+ !noEvents &&
+ this._triggerNodeEvent(
+ "beforeSelect",
+ node,
+ ctx.originalEvent
+ ) === false
+ ) {
+ return !!node.selected;
+ }
+ if (flag && opts.selectMode === 1) {
+ // single selection mode (we don't uncheck all tree nodes, for performance reasons)
+ if (tree.lastSelectedNode) {
+ tree.lastSelectedNode.setSelected(false);
+ }
+ node.selected = flag;
+ } else if (
+ opts.selectMode === 3 &&
+ parent &&
+ !parent.radiogroup &&
+ !node.radiogroup
+ ) {
+ // multi-hierarchical selection mode
+ node.selected = flag;
+ node.fixSelection3AfterClick(callOpts);
+ } else if (parent && parent.radiogroup) {
+ node.visitSiblings(function(n) {
+ n._changeSelectStatusAttrs(flag && n === node);
+ }, true);
+ } else {
+ // default: selectMode: 2, multi selection mode
+ node.selected = flag;
+ }
+ this.nodeRenderStatus(ctx);
+ tree.lastSelectedNode = flag ? node : null;
+ if (!noEvents) {
+ tree._triggerNodeEvent("select", ctx);
+ }
+ },
+ /** Show node status (ok, loading, error, nodata) using styles and a dummy child node.
+ *
+ * @param {EventData} ctx
+ * @param status
+ * @param message
+ * @param details
+ * @since 2.3
+ */
+ nodeSetStatus: function(ctx, status, message, details) {
+ var node = ctx.node,
+ tree = ctx.tree;
+
+ function _clearStatusNode() {
+ // Remove dedicated dummy node, if any
+ var firstChild = node.children ? node.children[0] : null;
+ if (firstChild && firstChild.isStatusNode()) {
+ try {
+ // I've seen exceptions here with loadKeyPath...
+ if (node.ul) {
+ node.ul.removeChild(firstChild.li);
+ firstChild.li = null; // avoid leaks (DT issue 215)
+ }
+ } catch (e) {}
+ if (node.children.length === 1) {
+ node.children = [];
+ } else {
+ node.children.shift();
+ }
+ tree._callHook(
+ "treeStructureChanged",
+ ctx,
+ "clearStatusNode"
+ );
+ }
+ }
+ function _setStatusNode(data, type) {
+ // Create/modify the dedicated dummy node for 'loading...' or
+ // 'error!' status. (only called for direct child of the invisible
+ // system root)
+ var firstChild = node.children ? node.children[0] : null;
+ if (firstChild && firstChild.isStatusNode()) {
+ $.extend(firstChild, data);
+ firstChild.statusNodeType = type;
+ tree._callHook("nodeRenderTitle", firstChild);
+ } else {
+ node._setChildren([data]);
+ tree._callHook(
+ "treeStructureChanged",
+ ctx,
+ "setStatusNode"
+ );
+ node.children[0].statusNodeType = type;
+ tree.render();
+ }
+ return node.children[0];
+ }
+
+ switch (status) {
+ case "ok":
+ _clearStatusNode();
+ node._isLoading = false;
+ node._error = null;
+ node.renderStatus();
+ break;
+ case "loading":
+ if (!node.parent) {
+ _setStatusNode(
+ {
+ title:
+ tree.options.strings.loading +
+ (message ? " (" + message + ")" : ""),
+ // icon: true, // needed for 'loding' icon
+ checkbox: false,
+ tooltip: details,
+ },
+ status
+ );
+ }
+ node._isLoading = true;
+ node._error = null;
+ node.renderStatus();
+ break;
+ case "error":
+ _setStatusNode(
+ {
+ title:
+ tree.options.strings.loadError +
+ (message ? " (" + message + ")" : ""),
+ // icon: false,
+ checkbox: false,
+ tooltip: details,
+ },
+ status
+ );
+ node._isLoading = false;
+ node._error = { message: message, details: details };
+ node.renderStatus();
+ break;
+ case "nodata":
+ _setStatusNode(
+ {
+ title: message || tree.options.strings.noData,
+ // icon: false,
+ checkbox: false,
+ tooltip: details,
+ },
+ status
+ );
+ node._isLoading = false;
+ node._error = null;
+ node.renderStatus();
+ break;
+ default:
+ $.error("invalid node status " + status);
+ }
+ },
+ /**
+ *
+ * @param {EventData} ctx
+ */
+ nodeToggleExpanded: function(ctx) {
+ return this.nodeSetExpanded(ctx, !ctx.node.expanded);
+ },
+ /**
+ * @param {EventData} ctx
+ */
+ nodeToggleSelected: function(ctx) {
+ var node = ctx.node,
+ flag = !node.selected;
+
+ // In selectMode: 3 this node may be unselected+partsel, even if
+ // setSelected(true) was called before, due to `unselectable` children.
+ // In this case, we now toggle as `setSelected(false)`
+ if (
+ node.partsel &&
+ !node.selected &&
+ node._lastSelectIntent === true
+ ) {
+ flag = false;
+ node.selected = true; // so it is not considered 'nothing to do'
+ }
+ node._lastSelectIntent = flag;
+ return this.nodeSetSelected(ctx, flag);
+ },
+ /** Remove all nodes.
+ * @param {EventData} ctx
+ */
+ treeClear: function(ctx) {
+ var tree = ctx.tree;
+ tree.activeNode = null;
+ tree.focusNode = null;
+ tree.$div.find(">ul.fancytree-container").empty();
+ // TODO: call destructors and remove reference loops
+ tree.rootNode.children = null;
+ tree._callHook("treeStructureChanged", ctx, "clear");
+ },
+ /** Widget was created (called only once, even it re-initialized).
+ * @param {EventData} ctx
+ */
+ treeCreate: function(ctx) {},
+ /** Widget was destroyed.
+ * @param {EventData} ctx
+ */
+ treeDestroy: function(ctx) {
+ this.$div.find(">ul.fancytree-container").remove();
+ if (this.$source) {
+ this.$source.removeClass("fancytree-helper-hidden");
+ }
+ },
+ /** Widget was (re-)initialized.
+ * @param {EventData} ctx
+ */
+ treeInit: function(ctx) {
+ var tree = ctx.tree,
+ opts = tree.options;
+
+ //this.debug("Fancytree.treeInit()");
+ // Add container to the TAB chain
+ // See http://www.w3.org/TR/wai-aria-practices/#focus_activedescendant
+ // #577: Allow to set tabindex to "0", "-1" and ""
+ tree.$container.attr("tabindex", opts.tabindex);
+
+ // Copy some attributes to tree.data
+ $.each(TREE_ATTRS, function(i, attr) {
+ if (opts[attr] !== undefined) {
+ tree.info("Move option " + attr + " to tree");
+ tree[attr] = opts[attr];
+ delete opts[attr];
+ }
+ });
+
+ if (opts.checkboxAutoHide) {
+ tree.$container.addClass("fancytree-checkbox-auto-hide");
+ }
+ if (opts.rtl) {
+ tree.$container
+ .attr("DIR", "RTL")
+ .addClass("fancytree-rtl");
+ } else {
+ tree.$container
+ .removeAttr("DIR")
+ .removeClass("fancytree-rtl");
+ }
+ if (opts.aria) {
+ tree.$container.attr("role", "tree");
+ if (opts.selectMode !== 1) {
+ tree.$container.attr("aria-multiselectable", true);
+ }
+ }
+ this.treeLoad(ctx);
+ },
+ /** Parse Fancytree from source, as configured in the options.
+ * @param {EventData} ctx
+ * @param {object} [source] optional new source (use last data otherwise)
+ */
+ treeLoad: function(ctx, source) {
+ var metaData,
+ type,
+ $ul,
+ tree = ctx.tree,
+ $container = ctx.widget.element,
+ dfd,
+ // calling context for root node
+ rootCtx = $.extend({}, ctx, { node: this.rootNode });
+
+ if (tree.rootNode.children) {
+ this.treeClear(ctx);
+ }
+ source = source || this.options.source;
+
+ if (!source) {
+ type = $container.data("type") || "html";
+ switch (type) {
+ case "html":
+ // There should be an embedded `` with initial nodes,
+ // but another `