import-layers/yocto-poky/bitbake/lib/toaster/toastergui/static/js/jquery.treetable.js - openbmc/openbmc - Gitiles

 /*
  * 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='#'>&nbsp;</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);
	/*
	* 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);