621 lines
16 KiB
JavaScript
621 lines
16 KiB
JavaScript
/*
|
|
* jQuery treetable Plugin 3.1.0
|
|
* http://ludo.cubicphuse.nl/jquery-treetable
|
|
*
|
|
* Copyright 2013, Ludo van den Boom
|
|
* Dual licensed under the MIT or GPL Version 2 licenses.
|
|
*/
|
|
(function() {
|
|
var $, Node, Tree, methods;
|
|
|
|
$ = jQuery;
|
|
|
|
Node = (function() {
|
|
function Node(row, tree, settings) {
|
|
var parentId;
|
|
|
|
this.row = row;
|
|
this.tree = tree;
|
|
this.settings = settings;
|
|
|
|
// TODO Ensure id/parentId is always a string (not int)
|
|
this.id = this.row.data(this.settings.nodeIdAttr);
|
|
|
|
// TODO Move this to a setParentId function?
|
|
parentId = this.row.data(this.settings.parentIdAttr);
|
|
if (parentId != null && parentId !== "") {
|
|
this.parentId = parentId;
|
|
}
|
|
|
|
this.treeCell = $(this.row.children(this.settings.columnElType)[this.settings.column]);
|
|
this.expander = $(this.settings.expanderTemplate);
|
|
this.indenter = $(this.settings.indenterTemplate);
|
|
this.children = [];
|
|
this.initialized = false;
|
|
this.treeCell.prepend(this.indenter);
|
|
}
|
|
|
|
Node.prototype.addChild = function(child) {
|
|
return this.children.push(child);
|
|
};
|
|
|
|
Node.prototype.ancestors = function() {
|
|
var ancestors, node;
|
|
node = this;
|
|
ancestors = [];
|
|
while (node = node.parentNode()) {
|
|
ancestors.push(node);
|
|
}
|
|
return ancestors;
|
|
};
|
|
|
|
Node.prototype.collapse = function() {
|
|
if (this.collapsed()) {
|
|
return this;
|
|
}
|
|
|
|
this.row.removeClass("expanded").addClass("collapsed");
|
|
|
|
this._hideChildren();
|
|
this.expander.attr("title", this.settings.stringExpand);
|
|
|
|
if (this.initialized && this.settings.onNodeCollapse != null) {
|
|
this.settings.onNodeCollapse.apply(this);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
Node.prototype.collapsed = function() {
|
|
return this.row.hasClass("collapsed");
|
|
};
|
|
|
|
// TODO destroy: remove event handlers, expander, indenter, etc.
|
|
|
|
Node.prototype.expand = function() {
|
|
if (this.expanded()) {
|
|
return this;
|
|
}
|
|
|
|
this.row.removeClass("collapsed").addClass("expanded");
|
|
|
|
if (this.initialized && this.settings.onNodeExpand != null) {
|
|
this.settings.onNodeExpand.apply(this);
|
|
}
|
|
|
|
if ($(this.row).is(":visible")) {
|
|
this._showChildren();
|
|
}
|
|
|
|
this.expander.attr("title", this.settings.stringCollapse);
|
|
|
|
return this;
|
|
};
|
|
|
|
Node.prototype.expanded = function() {
|
|
return this.row.hasClass("expanded");
|
|
};
|
|
|
|
Node.prototype.hide = function() {
|
|
this._hideChildren();
|
|
this.row.hide();
|
|
return this;
|
|
};
|
|
|
|
Node.prototype.isBranchNode = function() {
|
|
if(this.children.length > 0 || this.row.data(this.settings.branchAttr) === true) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
Node.prototype.updateBranchLeafClass = function(){
|
|
this.row.removeClass('branch');
|
|
this.row.removeClass('leaf');
|
|
this.row.addClass(this.isBranchNode() ? 'branch' : 'leaf');
|
|
};
|
|
|
|
Node.prototype.level = function() {
|
|
return this.ancestors().length;
|
|
};
|
|
|
|
Node.prototype.parentNode = function() {
|
|
if (this.parentId != null) {
|
|
return this.tree[this.parentId];
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
Node.prototype.removeChild = function(child) {
|
|
var i = $.inArray(child, this.children);
|
|
return this.children.splice(i, 1)
|
|
};
|
|
|
|
Node.prototype.render = function() {
|
|
var handler,
|
|
settings = this.settings,
|
|
target;
|
|
|
|
if (settings.expandable === true && this.isBranchNode()) {
|
|
handler = function(e) {
|
|
$(this).parents("table").treetable("node", $(this).parents("tr").data(settings.nodeIdAttr)).toggle();
|
|
return e.preventDefault();
|
|
};
|
|
|
|
this.indenter.html(this.expander);
|
|
target = settings.clickableNodeNames === true ? this.treeCell : this.expander;
|
|
|
|
target.off("click.treetable").on("click.treetable", handler);
|
|
target.off("keydown.treetable").on("keydown.treetable", function(e) {
|
|
if (e.keyCode == 13) {
|
|
handler.apply(this, [e]);
|
|
}
|
|
});
|
|
}
|
|
|
|
this.indenter[0].style.paddingLeft = "" + (this.level() * settings.indent) + "px";
|
|
|
|
return this;
|
|
};
|
|
|
|
Node.prototype.reveal = function() {
|
|
if (this.parentId != null) {
|
|
this.parentNode().reveal();
|
|
}
|
|
return this.expand();
|
|
};
|
|
|
|
Node.prototype.setParent = function(node) {
|
|
if (this.parentId != null) {
|
|
this.tree[this.parentId].removeChild(this);
|
|
}
|
|
this.parentId = node.id;
|
|
this.row.data(this.settings.parentIdAttr, node.id);
|
|
return node.addChild(this);
|
|
};
|
|
|
|
Node.prototype.show = function() {
|
|
if (!this.initialized) {
|
|
this._initialize();
|
|
}
|
|
this.row.show();
|
|
if (this.expanded()) {
|
|
this._showChildren();
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Node.prototype.toggle = function() {
|
|
if (this.expanded()) {
|
|
this.collapse();
|
|
} else {
|
|
this.expand();
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Node.prototype._hideChildren = function() {
|
|
var child, _i, _len, _ref, _results;
|
|
_ref = this.children;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
child = _ref[_i];
|
|
_results.push(child.hide());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Node.prototype._initialize = function() {
|
|
var settings = this.settings;
|
|
|
|
this.render();
|
|
|
|
if (settings.expandable === true && settings.initialState === "collapsed") {
|
|
this.collapse();
|
|
} else {
|
|
this.expand();
|
|
}
|
|
|
|
if (settings.onNodeInitialized != null) {
|
|
settings.onNodeInitialized.apply(this);
|
|
}
|
|
|
|
return this.initialized = true;
|
|
};
|
|
|
|
Node.prototype._showChildren = function() {
|
|
var child, _i, _len, _ref, _results;
|
|
_ref = this.children;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
child = _ref[_i];
|
|
_results.push(child.show());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
return Node;
|
|
})();
|
|
|
|
Tree = (function() {
|
|
function Tree(table, settings) {
|
|
this.table = table;
|
|
this.settings = settings;
|
|
this.tree = {};
|
|
|
|
// Cache the nodes and roots in simple arrays for quick access/iteration
|
|
this.nodes = [];
|
|
this.roots = [];
|
|
}
|
|
|
|
Tree.prototype.collapseAll = function() {
|
|
var node, _i, _len, _ref, _results;
|
|
_ref = this.nodes;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
node = _ref[_i];
|
|
_results.push(node.collapse());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Tree.prototype.expandAll = function() {
|
|
var node, _i, _len, _ref, _results;
|
|
_ref = this.nodes;
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
node = _ref[_i];
|
|
_results.push(node.expand());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Tree.prototype.findLastNode = function (node) {
|
|
if (node.children.length > 0) {
|
|
return this.findLastNode(node.children[node.children.length - 1]);
|
|
} else {
|
|
return node;
|
|
}
|
|
};
|
|
|
|
Tree.prototype.loadRows = function(rows) {
|
|
var node, row, i;
|
|
|
|
if (rows != null) {
|
|
for (i = 0; i < rows.length; i++) {
|
|
row = $(rows[i]);
|
|
|
|
if (row.data(this.settings.nodeIdAttr) != null) {
|
|
node = new Node(row, this.tree, this.settings);
|
|
this.nodes.push(node);
|
|
this.tree[node.id] = node;
|
|
|
|
if (node.parentId != null) {
|
|
this.tree[node.parentId].addChild(node);
|
|
} else {
|
|
this.roots.push(node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < this.nodes.length; i++) {
|
|
node = this.nodes[i].updateBranchLeafClass();
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
Tree.prototype.move = function(node, destination) {
|
|
// Conditions:
|
|
// 1: +node+ should not be inserted as a child of +node+ itself.
|
|
// 2: +destination+ should not be the same as +node+'s current parent (this
|
|
// prevents +node+ from being moved to the same location where it already
|
|
// is).
|
|
// 3: +node+ should not be inserted in a location in a branch if this would
|
|
// result in +node+ being an ancestor of itself.
|
|
var nodeParent = node.parentNode();
|
|
if (node !== destination && destination.id !== node.parentId && $.inArray(node, destination.ancestors()) === -1) {
|
|
node.setParent(destination);
|
|
this._moveRows(node, destination);
|
|
|
|
// Re-render parentNode if this is its first child node, and therefore
|
|
// doesn't have the expander yet.
|
|
if (node.parentNode().children.length === 1) {
|
|
node.parentNode().render();
|
|
}
|
|
}
|
|
|
|
if(nodeParent){
|
|
nodeParent.updateBranchLeafClass();
|
|
}
|
|
if(node.parentNode()){
|
|
node.parentNode().updateBranchLeafClass();
|
|
}
|
|
node.updateBranchLeafClass();
|
|
return this;
|
|
};
|
|
|
|
Tree.prototype.removeNode = function(node) {
|
|
// Recursively remove all descendants of +node+
|
|
this.unloadBranch(node);
|
|
|
|
// Remove node from DOM (<tr>)
|
|
node.row.remove();
|
|
|
|
// Clean up Tree object (so Node objects are GC-ed)
|
|
delete this.tree[node.id];
|
|
this.nodes.splice($.inArray(node, this.nodes), 1);
|
|
}
|
|
|
|
Tree.prototype.render = function() {
|
|
var root, _i, _len, _ref;
|
|
_ref = this.roots;
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
root = _ref[_i];
|
|
|
|
// Naming is confusing (show/render). I do not call render on node from
|
|
// here.
|
|
root.show();
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Tree.prototype.sortBranch = function(node, sortFun) {
|
|
// First sort internal array of children
|
|
node.children.sort(sortFun);
|
|
|
|
// Next render rows in correct order on page
|
|
this._sortChildRows(node);
|
|
|
|
return this;
|
|
};
|
|
|
|
Tree.prototype.unloadBranch = function(node) {
|
|
var children, i;
|
|
|
|
for (i = 0; i < node.children.length; i++) {
|
|
this.removeNode(node.children[i]);
|
|
}
|
|
|
|
// Reset node's collection of children
|
|
node.children = [];
|
|
|
|
node.updateBranchLeafClass();
|
|
|
|
return this;
|
|
};
|
|
|
|
Tree.prototype._moveRows = function(node, destination) {
|
|
var children = node.children, i;
|
|
|
|
node.row.insertAfter(destination.row);
|
|
node.render();
|
|
|
|
// Loop backwards through children to have them end up on UI in correct
|
|
// order (see #112)
|
|
for (i = children.length - 1; i >= 0; i--) {
|
|
this._moveRows(children[i], node);
|
|
}
|
|
};
|
|
|
|
// Special _moveRows case, move children to itself to force sorting
|
|
Tree.prototype._sortChildRows = function(parentNode) {
|
|
return this._moveRows(parentNode, parentNode);
|
|
};
|
|
|
|
return Tree;
|
|
})();
|
|
|
|
// jQuery Plugin
|
|
methods = {
|
|
init: function(options, force) {
|
|
var settings;
|
|
|
|
settings = $.extend({
|
|
branchAttr: "ttBranch",
|
|
clickableNodeNames: false,
|
|
column: 0,
|
|
columnElType: "td", // i.e. 'td', 'th' or 'td,th'
|
|
expandable: false,
|
|
expanderTemplate: "<a href='#'> </a>",
|
|
indent: 10,
|
|
indenterTemplate: "<span class='indenter'></span>",
|
|
initialState: "collapsed",
|
|
nodeIdAttr: "ttId", // maps to data-tt-id
|
|
parentIdAttr: "ttParentId", // maps to data-tt-parent-id
|
|
stringExpand: "Expand",
|
|
stringCollapse: "Collapse",
|
|
|
|
// Events
|
|
onInitialized: null,
|
|
onNodeCollapse: null,
|
|
onNodeExpand: null,
|
|
onNodeInitialized: null
|
|
}, options);
|
|
|
|
return this.each(function() {
|
|
var el = $(this), tree;
|
|
|
|
if (force || el.data("treetable") === undefined) {
|
|
tree = new Tree(this, settings);
|
|
tree.loadRows(this.rows).render();
|
|
|
|
el.addClass("treetable").data("treetable", tree);
|
|
|
|
if (settings.onInitialized != null) {
|
|
settings.onInitialized.apply(tree);
|
|
}
|
|
}
|
|
|
|
return el;
|
|
});
|
|
},
|
|
|
|
destroy: function() {
|
|
return this.each(function() {
|
|
return $(this).removeData("treetable").removeClass("treetable");
|
|
});
|
|
},
|
|
|
|
collapseAll: function() {
|
|
this.data("treetable").collapseAll();
|
|
return this;
|
|
},
|
|
|
|
collapseNode: function(id) {
|
|
var node = this.data("treetable").tree[id];
|
|
|
|
if (node) {
|
|
node.collapse();
|
|
} else {
|
|
throw new Error("Unknown node '" + id + "'");
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
expandAll: function() {
|
|
this.data("treetable").expandAll();
|
|
return this;
|
|
},
|
|
|
|
expandNode: function(id) {
|
|
var node = this.data("treetable").tree[id];
|
|
|
|
if (node) {
|
|
if (!node.initialized) {
|
|
node._initialize();
|
|
}
|
|
|
|
node.expand();
|
|
} else {
|
|
throw new Error("Unknown node '" + id + "'");
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
loadBranch: function(node, rows) {
|
|
var settings = this.data("treetable").settings,
|
|
tree = this.data("treetable").tree;
|
|
|
|
// TODO Switch to $.parseHTML
|
|
rows = $(rows);
|
|
|
|
if (node == null) { // Inserting new root nodes
|
|
this.append(rows);
|
|
} else {
|
|
var lastNode = this.data("treetable").findLastNode(node);
|
|
rows.insertAfter(lastNode.row);
|
|
}
|
|
|
|
this.data("treetable").loadRows(rows);
|
|
|
|
// Make sure nodes are properly initialized
|
|
rows.filter("tr").each(function() {
|
|
tree[$(this).data(settings.nodeIdAttr)].show();
|
|
});
|
|
|
|
if (node != null) {
|
|
// Re-render parent to ensure expander icon is shown (#79)
|
|
node.render().expand();
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
move: function(nodeId, destinationId) {
|
|
var destination, node;
|
|
|
|
node = this.data("treetable").tree[nodeId];
|
|
destination = this.data("treetable").tree[destinationId];
|
|
this.data("treetable").move(node, destination);
|
|
|
|
return this;
|
|
},
|
|
|
|
node: function(id) {
|
|
return this.data("treetable").tree[id];
|
|
},
|
|
|
|
removeNode: function(id) {
|
|
var node = this.data("treetable").tree[id];
|
|
|
|
if (node) {
|
|
this.data("treetable").removeNode(node);
|
|
} else {
|
|
throw new Error("Unknown node '" + id + "'");
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
reveal: function(id) {
|
|
var node = this.data("treetable").tree[id];
|
|
|
|
if (node) {
|
|
node.reveal();
|
|
} else {
|
|
throw new Error("Unknown node '" + id + "'");
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
sortBranch: function(node, columnOrFunction) {
|
|
var settings = this.data("treetable").settings,
|
|
prepValue,
|
|
sortFun;
|
|
|
|
columnOrFunction = columnOrFunction || settings.column;
|
|
sortFun = columnOrFunction;
|
|
|
|
if ($.isNumeric(columnOrFunction)) {
|
|
sortFun = function(a, b) {
|
|
var extractValue, valA, valB;
|
|
|
|
extractValue = function(node) {
|
|
var val = node.row.find("td:eq(" + columnOrFunction + ")").text();
|
|
// Ignore trailing/leading whitespace and use uppercase values for
|
|
// case insensitive ordering
|
|
return $.trim(val).toUpperCase();
|
|
}
|
|
|
|
valA = extractValue(a);
|
|
valB = extractValue(b);
|
|
|
|
if (valA < valB) return -1;
|
|
if (valA > valB) return 1;
|
|
return 0;
|
|
};
|
|
}
|
|
|
|
this.data("treetable").sortBranch(node, sortFun);
|
|
return this;
|
|
},
|
|
|
|
unloadBranch: function(node) {
|
|
this.data("treetable").unloadBranch(node);
|
|
return this;
|
|
}
|
|
};
|
|
|
|
$.fn.treetable = function(method) {
|
|
if (methods[method]) {
|
|
return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
|
|
} else if (typeof method === 'object' || !method) {
|
|
return methods.init.apply(this, arguments);
|
|
} else {
|
|
return $.error("Method " + method + " does not exist on jQuery.treetable");
|
|
}
|
|
};
|
|
|
|
// Expose classes to world
|
|
this.TreeTable || (this.TreeTable = {});
|
|
this.TreeTable.Node = Node;
|
|
this.TreeTable.Tree = Tree;
|
|
}).call(this);
|