diff options
Diffstat (limited to 'ecomp-portal-FE/client/bower_components/jqTree/tree.jquery.js')
| -rw-r--r-- | ecomp-portal-FE/client/bower_components/jqTree/tree.jquery.js | 3640 |
1 files changed, 3640 insertions, 0 deletions
diff --git a/ecomp-portal-FE/client/bower_components/jqTree/tree.jquery.js b/ecomp-portal-FE/client/bower_components/jqTree/tree.jquery.js new file mode 100644 index 00000000..dd42aa0b --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/jqTree/tree.jquery.js @@ -0,0 +1,3640 @@ +/* +JqTree 1.3.7 + +Copyright 2015 Marco Braak + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ +var $, DragAndDropHandler, DragElement, HitAreasGenerator, Position, VisibleNodeIterator, node_module, util, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +node_module = require('./node'); + +util = require('./util'); + +Position = node_module.Position; + +$ = jQuery; + +DragAndDropHandler = (function() { + function DragAndDropHandler(tree_widget) { + this.tree_widget = tree_widget; + this.hovered_area = null; + this.$ghost = null; + this.hit_areas = []; + this.is_dragging = false; + this.current_item = null; + } + + DragAndDropHandler.prototype.mouseCapture = function(position_info) { + var $element, node_element; + $element = $(position_info.target); + if (!this.mustCaptureElement($element)) { + return null; + } + if (this.tree_widget.options.onIsMoveHandle && !this.tree_widget.options.onIsMoveHandle($element)) { + return null; + } + node_element = this.tree_widget._getNodeElement($element); + if (node_element && this.tree_widget.options.onCanMove) { + if (!this.tree_widget.options.onCanMove(node_element.node)) { + node_element = null; + } + } + this.current_item = node_element; + return this.current_item !== null; + }; + + DragAndDropHandler.prototype.mouseStart = function(position_info) { + var node, node_name, offset; + this.refresh(); + offset = $(position_info.target).offset(); + node = this.current_item.node; + if (this.tree_widget.options.autoEscape) { + node_name = util.html_escape(node.name); + } else { + node_name = node.name; + } + this.drag_element = new DragElement(node_name, position_info.page_x - offset.left, position_info.page_y - offset.top, this.tree_widget.element); + this.is_dragging = true; + this.current_item.$element.addClass('jqtree-moving'); + return true; + }; + + DragAndDropHandler.prototype.mouseDrag = function(position_info) { + var area, can_move_to; + this.drag_element.move(position_info.page_x, position_info.page_y); + area = this.findHoveredArea(position_info.page_x, position_info.page_y); + can_move_to = this.canMoveToArea(area); + if (can_move_to && area) { + if (!area.node.isFolder()) { + this.stopOpenFolderTimer(); + } + if (this.hovered_area !== area) { + this.hovered_area = area; + if (this.mustOpenFolderTimer(area)) { + this.startOpenFolderTimer(area.node); + } else { + this.stopOpenFolderTimer(); + } + this.updateDropHint(); + } + } else { + this.removeHover(); + this.removeDropHint(); + this.stopOpenFolderTimer(); + } + if (!area) { + if (this.tree_widget.options.onDragMove != null) { + this.tree_widget.options.onDragMove(this.current_item.node, position_info.original_event); + } + } + return true; + }; + + DragAndDropHandler.prototype.mustCaptureElement = function($element) { + return !$element.is('input,select,textarea'); + }; + + DragAndDropHandler.prototype.canMoveToArea = function(area) { + var position_name; + if (!area) { + return false; + } else if (this.tree_widget.options.onCanMoveTo) { + position_name = Position.getName(area.position); + return this.tree_widget.options.onCanMoveTo(this.current_item.node, area.node, position_name); + } else { + return true; + } + }; + + DragAndDropHandler.prototype.mouseStop = function(position_info) { + var current_item; + this.moveItem(position_info); + this.clear(); + this.removeHover(); + this.removeDropHint(); + this.removeHitAreas(); + current_item = this.current_item; + if (this.current_item) { + this.current_item.$element.removeClass('jqtree-moving'); + this.current_item = null; + } + this.is_dragging = false; + if (!this.hovered_area && current_item) { + if (this.tree_widget.options.onDragStop != null) { + this.tree_widget.options.onDragStop(current_item.node, position_info.original_event); + } + } + return false; + }; + + DragAndDropHandler.prototype.refresh = function() { + this.removeHitAreas(); + if (this.current_item) { + this.generateHitAreas(); + this.current_item = this.tree_widget._getNodeElementForNode(this.current_item.node); + if (this.is_dragging) { + return this.current_item.$element.addClass('jqtree-moving'); + } + } + }; + + DragAndDropHandler.prototype.removeHitAreas = function() { + return this.hit_areas = []; + }; + + DragAndDropHandler.prototype.clear = function() { + this.drag_element.remove(); + return this.drag_element = null; + }; + + DragAndDropHandler.prototype.removeDropHint = function() { + if (this.previous_ghost) { + return this.previous_ghost.remove(); + } + }; + + DragAndDropHandler.prototype.removeHover = function() { + return this.hovered_area = null; + }; + + DragAndDropHandler.prototype.generateHitAreas = function() { + var hit_areas_generator; + hit_areas_generator = new HitAreasGenerator(this.tree_widget.tree, this.current_item.node, this.getTreeDimensions().bottom); + return this.hit_areas = hit_areas_generator.generate(); + }; + + DragAndDropHandler.prototype.findHoveredArea = function(x, y) { + var area, dimensions, high, low, mid; + dimensions = this.getTreeDimensions(); + if (x < dimensions.left || y < dimensions.top || x > dimensions.right || y > dimensions.bottom) { + return null; + } + low = 0; + high = this.hit_areas.length; + while (low < high) { + mid = (low + high) >> 1; + area = this.hit_areas[mid]; + if (y < area.top) { + high = mid; + } else if (y > area.bottom) { + low = mid + 1; + } else { + return area; + } + } + return null; + }; + + DragAndDropHandler.prototype.mustOpenFolderTimer = function(area) { + var node; + node = area.node; + return node.isFolder() && !node.is_open && area.position === Position.INSIDE; + }; + + DragAndDropHandler.prototype.updateDropHint = function() { + var node_element; + if (!this.hovered_area) { + return; + } + this.removeDropHint(); + node_element = this.tree_widget._getNodeElementForNode(this.hovered_area.node); + return this.previous_ghost = node_element.addDropHint(this.hovered_area.position); + }; + + DragAndDropHandler.prototype.startOpenFolderTimer = function(folder) { + var openFolder; + openFolder = (function(_this) { + return function() { + return _this.tree_widget._openNode(folder, _this.tree_widget.options.slide, function() { + _this.refresh(); + return _this.updateDropHint(); + }); + }; + })(this); + this.stopOpenFolderTimer(); + return this.open_folder_timer = setTimeout(openFolder, this.tree_widget.options.openFolderDelay); + }; + + DragAndDropHandler.prototype.stopOpenFolderTimer = function() { + if (this.open_folder_timer) { + clearTimeout(this.open_folder_timer); + return this.open_folder_timer = null; + } + }; + + DragAndDropHandler.prototype.moveItem = function(position_info) { + var doMove, event, moved_node, position, previous_parent, target_node; + if (this.hovered_area && this.hovered_area.position !== Position.NONE && this.canMoveToArea(this.hovered_area)) { + moved_node = this.current_item.node; + target_node = this.hovered_area.node; + position = this.hovered_area.position; + previous_parent = moved_node.parent; + if (position === Position.INSIDE) { + this.hovered_area.node.is_open = true; + } + doMove = (function(_this) { + return function() { + _this.tree_widget.tree.moveNode(moved_node, target_node, position); + _this.tree_widget.element.empty(); + return _this.tree_widget._refreshElements(); + }; + })(this); + event = this.tree_widget._triggerEvent('tree.move', { + move_info: { + moved_node: moved_node, + target_node: target_node, + position: Position.getName(position), + previous_parent: previous_parent, + do_move: doMove, + original_event: position_info.original_event + } + }); + if (!event.isDefaultPrevented()) { + return doMove(); + } + } + }; + + DragAndDropHandler.prototype.getTreeDimensions = function() { + var offset; + offset = this.tree_widget.element.offset(); + return { + left: offset.left, + top: offset.top, + right: offset.left + this.tree_widget.element.width(), + bottom: offset.top + this.tree_widget.element.height() + 16 + }; + }; + + return DragAndDropHandler; + +})(); + +VisibleNodeIterator = (function() { + function VisibleNodeIterator(tree) { + this.tree = tree; + } + + VisibleNodeIterator.prototype.iterate = function() { + var _iterateNode, is_first_node; + is_first_node = true; + _iterateNode = (function(_this) { + return function(node, next_node) { + var $element, child, children_length, i, j, len, must_iterate_inside, ref; + must_iterate_inside = (node.is_open || !node.element) && node.hasChildren(); + if (node.element) { + $element = $(node.element); + if (!$element.is(':visible')) { + return; + } + if (is_first_node) { + _this.handleFirstNode(node, $element); + is_first_node = false; + } + if (!node.hasChildren()) { + _this.handleNode(node, next_node, $element); + } else if (node.is_open) { + if (!_this.handleOpenFolder(node, $element)) { + must_iterate_inside = false; + } + } else { + _this.handleClosedFolder(node, next_node, $element); + } + } + if (must_iterate_inside) { + children_length = node.children.length; + ref = node.children; + for (i = j = 0, len = ref.length; j < len; i = ++j) { + child = ref[i]; + if (i === (children_length - 1)) { + _iterateNode(node.children[i], null); + } else { + _iterateNode(node.children[i], node.children[i + 1]); + } + } + if (node.is_open) { + return _this.handleAfterOpenFolder(node, next_node, $element); + } + } + }; + })(this); + return _iterateNode(this.tree, null); + }; + + VisibleNodeIterator.prototype.handleNode = function(node, next_node, $element) {}; + + VisibleNodeIterator.prototype.handleOpenFolder = function(node, $element) {}; + + VisibleNodeIterator.prototype.handleClosedFolder = function(node, next_node, $element) {}; + + VisibleNodeIterator.prototype.handleAfterOpenFolder = function(node, next_node, $element) {}; + + VisibleNodeIterator.prototype.handleFirstNode = function(node, $element) {}; + + return VisibleNodeIterator; + +})(); + +HitAreasGenerator = (function(superClass) { + extend(HitAreasGenerator, superClass); + + function HitAreasGenerator(tree, current_node, tree_bottom) { + HitAreasGenerator.__super__.constructor.call(this, tree); + this.current_node = current_node; + this.tree_bottom = tree_bottom; + } + + HitAreasGenerator.prototype.generate = function() { + this.positions = []; + this.last_top = 0; + this.iterate(); + return this.generateHitAreas(this.positions); + }; + + HitAreasGenerator.prototype.getTop = function($element) { + return $element.offset().top; + }; + + HitAreasGenerator.prototype.addPosition = function(node, position, top) { + var area; + area = { + top: top, + node: node, + position: position + }; + this.positions.push(area); + return this.last_top = top; + }; + + HitAreasGenerator.prototype.handleNode = function(node, next_node, $element) { + var top; + top = this.getTop($element); + if (node === this.current_node) { + this.addPosition(node, Position.NONE, top); + } else { + this.addPosition(node, Position.INSIDE, top); + } + if (next_node === this.current_node || node === this.current_node) { + return this.addPosition(node, Position.NONE, top); + } else { + return this.addPosition(node, Position.AFTER, top); + } + }; + + HitAreasGenerator.prototype.handleOpenFolder = function(node, $element) { + if (node === this.current_node) { + return false; + } + if (node.children[0] !== this.current_node) { + this.addPosition(node, Position.INSIDE, this.getTop($element)); + } + return true; + }; + + HitAreasGenerator.prototype.handleClosedFolder = function(node, next_node, $element) { + var top; + top = this.getTop($element); + if (node === this.current_node) { + return this.addPosition(node, Position.NONE, top); + } else { + this.addPosition(node, Position.INSIDE, top); + if (next_node !== this.current_node) { + return this.addPosition(node, Position.AFTER, top); + } + } + }; + + HitAreasGenerator.prototype.handleFirstNode = function(node, $element) { + if (node !== this.current_node) { + return this.addPosition(node, Position.BEFORE, this.getTop($(node.element))); + } + }; + + HitAreasGenerator.prototype.handleAfterOpenFolder = function(node, next_node, $element) { + if (node === this.current_node.node || next_node === this.current_node.node) { + return this.addPosition(node, Position.NONE, this.last_top); + } else { + return this.addPosition(node, Position.AFTER, this.last_top); + } + }; + + HitAreasGenerator.prototype.generateHitAreas = function(positions) { + var group, hit_areas, j, len, position, previous_top; + previous_top = -1; + group = []; + hit_areas = []; + for (j = 0, len = positions.length; j < len; j++) { + position = positions[j]; + if (position.top !== previous_top && group.length) { + if (group.length) { + this.generateHitAreasForGroup(hit_areas, group, previous_top, position.top); + } + previous_top = position.top; + group = []; + } + group.push(position); + } + this.generateHitAreasForGroup(hit_areas, group, previous_top, this.tree_bottom); + return hit_areas; + }; + + HitAreasGenerator.prototype.generateHitAreasForGroup = function(hit_areas, positions_in_group, top, bottom) { + var area_height, area_top, i, position, position_count; + position_count = Math.min(positions_in_group.length, 4); + area_height = Math.round((bottom - top) / position_count); + area_top = top; + i = 0; + while (i < position_count) { + position = positions_in_group[i]; + hit_areas.push({ + top: area_top, + bottom: area_top + area_height, + node: position.node, + position: position.position + }); + area_top += area_height; + i += 1; + } + return null; + }; + + return HitAreasGenerator; + +})(VisibleNodeIterator); + +DragElement = (function() { + function DragElement(node_name, offset_x, offset_y, $tree) { + this.offset_x = offset_x; + this.offset_y = offset_y; + this.$element = $("<span class=\"jqtree-title jqtree-dragging\">" + node_name + "</span>"); + this.$element.css("position", "absolute"); + $tree.append(this.$element); + } + + DragElement.prototype.move = function(page_x, page_y) { + return this.$element.offset({ + left: page_x - this.offset_x, + top: page_y - this.offset_y + }); + }; + + DragElement.prototype.remove = function() { + return this.$element.remove(); + }; + + return DragElement; + +})(); + +module.exports = { + DragAndDropHandler: DragAndDropHandler, + DragElement: DragElement, + HitAreasGenerator: HitAreasGenerator +}; + +},{"./node":5,"./util":12}],2:[function(require,module,exports){ +var $, ElementsRenderer, NodeElement, html_escape, node_element, util; + +node_element = require('./node_element'); + +NodeElement = node_element.NodeElement; + +util = require('./util'); + +html_escape = util.html_escape; + +$ = jQuery; + +ElementsRenderer = (function() { + function ElementsRenderer(tree_widget) { + this.tree_widget = tree_widget; + this.opened_icon_element = this.createButtonElement(tree_widget.options.openedIcon); + this.closed_icon_element = this.createButtonElement(tree_widget.options.closedIcon); + } + + ElementsRenderer.prototype.render = function(from_node) { + if (from_node && from_node.parent) { + return this.renderFromNode(from_node); + } else { + return this.renderFromRoot(); + } + }; + + ElementsRenderer.prototype.renderFromRoot = function() { + var $element; + $element = this.tree_widget.element; + $element.empty(); + return this.createDomElements($element[0], this.tree_widget.tree.children, true, true, 1); + }; + + ElementsRenderer.prototype.renderFromNode = function(node) { + var $previous_li, li; + $previous_li = $(node.element); + li = this.createLi(node, node.getLevel()); + this.attachNodeData(node, li); + $previous_li.after(li); + $previous_li.remove(); + if (node.children) { + return this.createDomElements(li, node.children, false, false, node.getLevel() + 1); + } + }; + + ElementsRenderer.prototype.createDomElements = function(element, children, is_root_node, is_open, level) { + var child, i, len, li, ul; + ul = this.createUl(is_root_node); + element.appendChild(ul); + for (i = 0, len = children.length; i < len; i++) { + child = children[i]; + li = this.createLi(child, level); + ul.appendChild(li); + this.attachNodeData(child, li); + if (child.hasChildren()) { + this.createDomElements(li, child.children, false, child.is_open, level + 1); + } + } + return null; + }; + + ElementsRenderer.prototype.attachNodeData = function(node, li) { + node.element = li; + return $(li).data('node', node); + }; + + ElementsRenderer.prototype.createUl = function(is_root_node) { + var class_string, role, ul; + if (!is_root_node) { + class_string = ''; + role = 'group'; + } else { + class_string = 'jqtree-tree'; + role = 'tree'; + if (this.tree_widget.options.rtl) { + class_string += ' jqtree-rtl'; + } + } + ul = document.createElement('ul'); + ul.className = "jqtree_common " + class_string; + ul.setAttribute('role', role); + return ul; + }; + + ElementsRenderer.prototype.createLi = function(node, level) { + var is_selected, li; + is_selected = this.tree_widget.select_node_handler && this.tree_widget.select_node_handler.isNodeSelected(node); + if (node.isFolder()) { + li = this.createFolderLi(node, level, is_selected); + } else { + li = this.createNodeLi(node, level, is_selected); + } + if (this.tree_widget.options.onCreateLi) { + this.tree_widget.options.onCreateLi(node, $(li)); + } + return li; + }; + + ElementsRenderer.prototype.createFolderLi = function(node, level, is_selected) { + var button_classes, button_link, div, folder_classes, icon_element, is_folder, li; + button_classes = this.getButtonClasses(node); + folder_classes = this.getFolderClasses(node, is_selected); + if (node.is_open) { + icon_element = this.opened_icon_element; + } else { + icon_element = this.closed_icon_element; + } + li = document.createElement('li'); + li.className = "jqtree_common " + folder_classes; + li.setAttribute('role', 'presentation'); + div = document.createElement('div'); + div.className = "jqtree-element jqtree_common"; + div.setAttribute('role', 'presentation'); + li.appendChild(div); + button_link = document.createElement('a'); + button_link.className = button_classes; + button_link.appendChild(icon_element.cloneNode(false)); + button_link.setAttribute('role', 'presentation'); + button_link.setAttribute('aria-hidden', 'true'); + if (this.tree_widget.options.buttonLeft) { + div.appendChild(button_link); + } + div.appendChild(this.createTitleSpan(node.name, level, is_selected, node.is_open, is_folder = true)); + if (!this.tree_widget.options.buttonLeft) { + div.appendChild(button_link); + } + return li; + }; + + ElementsRenderer.prototype.createNodeLi = function(node, level, is_selected) { + var class_string, div, is_folder, li, li_classes; + li_classes = ['jqtree_common']; + if (is_selected) { + li_classes.push('jqtree-selected'); + } + class_string = li_classes.join(' '); + li = document.createElement('li'); + li.className = class_string; + li.setAttribute('role', 'presentation'); + div = document.createElement('div'); + div.className = "jqtree-element jqtree_common"; + div.setAttribute('role', 'presentation'); + li.appendChild(div); + div.appendChild(this.createTitleSpan(node.name, level, is_selected, node.is_open, is_folder = false)); + return li; + }; + + ElementsRenderer.prototype.createTitleSpan = function(node_name, level, is_selected, is_open, is_folder) { + var classes, title_span; + title_span = document.createElement('span'); + classes = "jqtree-title jqtree_common"; + if (is_folder) { + classes += " jqtree-title-folder"; + } + title_span.className = classes; + title_span.setAttribute('role', 'treeitem'); + title_span.setAttribute('aria-level', level); + title_span.setAttribute('aria-selected', util.getBoolString(is_selected)); + title_span.setAttribute('aria-expanded', util.getBoolString(is_open)); + if (is_selected) { + title_span.setAttribute('tabindex', 0); + } + title_span.innerHTML = this.escapeIfNecessary(node_name); + return title_span; + }; + + ElementsRenderer.prototype.getButtonClasses = function(node) { + var classes; + classes = ['jqtree-toggler', 'jqtree_common']; + if (!node.is_open) { + classes.push('jqtree-closed'); + } + if (this.tree_widget.options.buttonLeft) { + classes.push('jqtree-toggler-left'); + } else { + classes.push('jqtree-toggler-right'); + } + return classes.join(' '); + }; + + ElementsRenderer.prototype.getFolderClasses = function(node, is_selected) { + var classes; + classes = ['jqtree-folder']; + if (!node.is_open) { + classes.push('jqtree-closed'); + } + if (is_selected) { + classes.push('jqtree-selected'); + } + if (node.is_loading) { + classes.push('jqtree-loading'); + } + return classes.join(' '); + }; + + ElementsRenderer.prototype.escapeIfNecessary = function(value) { + if (this.tree_widget.options.autoEscape) { + return html_escape(value); + } else { + return value; + } + }; + + ElementsRenderer.prototype.createButtonElement = function(value) { + var div; + if (typeof value === 'string') { + div = document.createElement('div'); + div.innerHTML = value; + return document.createTextNode(div.innerHTML); + } else { + return $(value)[0]; + } + }; + + return ElementsRenderer; + +})(); + +module.exports = ElementsRenderer; + +},{"./node_element":6,"./util":12}],3:[function(require,module,exports){ +var $, KeyHandler, + bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }; + +$ = jQuery; + +KeyHandler = (function() { + var DOWN, LEFT, RIGHT, UP; + + LEFT = 37; + + UP = 38; + + RIGHT = 39; + + DOWN = 40; + + function KeyHandler(tree_widget) { + this.selectNode = bind(this.selectNode, this); + this.tree_widget = tree_widget; + if (tree_widget.options.keyboardSupport) { + $(document).bind('keydown.jqtree', $.proxy(this.handleKeyDown, this)); + } + } + + KeyHandler.prototype.deinit = function() { + return $(document).unbind('keydown.jqtree'); + }; + + KeyHandler.prototype.moveDown = function() { + var node; + node = this.tree_widget.getSelectedNode(); + if (node) { + return this.selectNode(node.getNextNode()); + } else { + return false; + } + }; + + KeyHandler.prototype.moveUp = function() { + var node; + node = this.tree_widget.getSelectedNode(); + if (node) { + return this.selectNode(node.getPreviousNode()); + } else { + return false; + } + }; + + KeyHandler.prototype.moveRight = function() { + var node; + node = this.tree_widget.getSelectedNode(); + if (!node) { + return true; + } else if (!node.isFolder()) { + return true; + } else { + if (node.is_open) { + return this.selectNode(node.getNextNode()); + } else { + this.tree_widget.openNode(node); + return false; + } + } + }; + + KeyHandler.prototype.moveLeft = function() { + var node; + node = this.tree_widget.getSelectedNode(); + if (!node) { + return true; + } else if (node.isFolder() && node.is_open) { + this.tree_widget.closeNode(node); + return false; + } else { + return this.selectNode(node.getParent()); + } + }; + + KeyHandler.prototype.handleKeyDown = function(e) { + var key; + if (!this.tree_widget.options.keyboardSupport) { + return true; + } + if ($(document.activeElement).is('textarea,input,select')) { + return true; + } + if (!this.tree_widget.getSelectedNode()) { + return true; + } + key = e.which; + switch (key) { + case DOWN: + return this.moveDown(); + case UP: + return this.moveUp(); + case RIGHT: + return this.moveRight(); + case LEFT: + return this.moveLeft(); + } + return true; + }; + + KeyHandler.prototype.selectNode = function(node) { + if (!node) { + return true; + } else { + this.tree_widget.selectNode(node); + if (this.tree_widget.scroll_handler && (!this.tree_widget.scroll_handler.isScrolledIntoView($(node.element).find('.jqtree-element')))) { + this.tree_widget.scrollToNode(node); + } + return false; + } + }; + + return KeyHandler; + +})(); + +module.exports = KeyHandler; + +},{}],4:[function(require,module,exports){ + +/* +This widget does the same a the mouse widget in jqueryui. + */ +var $, MouseWidget, SimpleWidget, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +SimpleWidget = require('./simple.widget'); + +$ = jQuery; + +MouseWidget = (function(superClass) { + extend(MouseWidget, superClass); + + function MouseWidget() { + return MouseWidget.__super__.constructor.apply(this, arguments); + } + + MouseWidget.is_mouse_handled = false; + + MouseWidget.prototype._init = function() { + this.$el.bind('mousedown.mousewidget', $.proxy(this._mouseDown, this)); + this.$el.bind('touchstart.mousewidget', $.proxy(this._touchStart, this)); + this.is_mouse_started = false; + this.mouse_delay = 0; + this._mouse_delay_timer = null; + this._is_mouse_delay_met = true; + return this.mouse_down_info = null; + }; + + MouseWidget.prototype._deinit = function() { + var $document; + this.$el.unbind('mousedown.mousewidget'); + this.$el.unbind('touchstart.mousewidget'); + $document = $(document); + $document.unbind('mousemove.mousewidget'); + return $document.unbind('mouseup.mousewidget'); + }; + + MouseWidget.prototype._mouseDown = function(e) { + var result; + if (e.which !== 1) { + return; + } + result = this._handleMouseDown(e, this._getPositionInfo(e)); + if (result) { + e.preventDefault(); + } + return result; + }; + + MouseWidget.prototype._handleMouseDown = function(e, position_info) { + if (MouseWidget.is_mouse_handled) { + return; + } + if (this.is_mouse_started) { + this._handleMouseUp(position_info); + } + this.mouse_down_info = position_info; + if (!this._mouseCapture(position_info)) { + return; + } + this._handleStartMouse(); + this.is_mouse_handled = true; + return true; + }; + + MouseWidget.prototype._handleStartMouse = function() { + var $document; + $document = $(document); + $document.bind('mousemove.mousewidget', $.proxy(this._mouseMove, this)); + $document.bind('touchmove.mousewidget', $.proxy(this._touchMove, this)); + $document.bind('mouseup.mousewidget', $.proxy(this._mouseUp, this)); + $document.bind('touchend.mousewidget', $.proxy(this._touchEnd, this)); + if (this.mouse_delay) { + return this._startMouseDelayTimer(); + } + }; + + MouseWidget.prototype._startMouseDelayTimer = function() { + if (this._mouse_delay_timer) { + clearTimeout(this._mouse_delay_timer); + } + this._mouse_delay_timer = setTimeout((function(_this) { + return function() { + return _this._is_mouse_delay_met = true; + }; + })(this), this.mouse_delay); + return this._is_mouse_delay_met = false; + }; + + MouseWidget.prototype._mouseMove = function(e) { + return this._handleMouseMove(e, this._getPositionInfo(e)); + }; + + MouseWidget.prototype._handleMouseMove = function(e, position_info) { + if (this.is_mouse_started) { + this._mouseDrag(position_info); + return e.preventDefault(); + } + if (this.mouse_delay && !this._is_mouse_delay_met) { + return true; + } + this.is_mouse_started = this._mouseStart(this.mouse_down_info) !== false; + if (this.is_mouse_started) { + this._mouseDrag(position_info); + } else { + this._handleMouseUp(position_info); + } + return !this.is_mouse_started; + }; + + MouseWidget.prototype._getPositionInfo = function(e) { + return { + page_x: e.pageX, + page_y: e.pageY, + target: e.target, + original_event: e + }; + }; + + MouseWidget.prototype._mouseUp = function(e) { + return this._handleMouseUp(this._getPositionInfo(e)); + }; + + MouseWidget.prototype._handleMouseUp = function(position_info) { + var $document; + $document = $(document); + $document.unbind('mousemove.mousewidget'); + $document.unbind('touchmove.mousewidget'); + $document.unbind('mouseup.mousewidget'); + $document.unbind('touchend.mousewidget'); + if (this.is_mouse_started) { + this.is_mouse_started = false; + this._mouseStop(position_info); + } + }; + + MouseWidget.prototype._mouseCapture = function(position_info) { + return true; + }; + + MouseWidget.prototype._mouseStart = function(position_info) { + return null; + }; + + MouseWidget.prototype._mouseDrag = function(position_info) { + return null; + }; + + MouseWidget.prototype._mouseStop = function(position_info) { + return null; + }; + + MouseWidget.prototype.setMouseDelay = function(mouse_delay) { + return this.mouse_delay = mouse_delay; + }; + + MouseWidget.prototype._touchStart = function(e) { + var touch; + if (e.originalEvent.touches.length > 1) { + return; + } + touch = e.originalEvent.changedTouches[0]; + return this._handleMouseDown(e, this._getPositionInfo(touch)); + }; + + MouseWidget.prototype._touchMove = function(e) { + var touch; + if (e.originalEvent.touches.length > 1) { + return; + } + touch = e.originalEvent.changedTouches[0]; + return this._handleMouseMove(e, this._getPositionInfo(touch)); + }; + + MouseWidget.prototype._touchEnd = function(e) { + var touch; + if (e.originalEvent.touches.length > 1) { + return; + } + touch = e.originalEvent.changedTouches[0]; + return this._handleMouseUp(this._getPositionInfo(touch)); + }; + + return MouseWidget; + +})(SimpleWidget); + +module.exports = MouseWidget; + +},{"./simple.widget":10}],5:[function(require,module,exports){ +var $, Node, Position; + +$ = jQuery; + +Position = { + getName: function(position) { + return Position.strings[position - 1]; + }, + nameToIndex: function(name) { + var i, j, ref; + for (i = j = 1, ref = Position.strings.length; 1 <= ref ? j <= ref : j >= ref; i = 1 <= ref ? ++j : --j) { + if (Position.strings[i - 1] === name) { + return i; + } + } + return 0; + } +}; + +Position.BEFORE = 1; + +Position.AFTER = 2; + +Position.INSIDE = 3; + +Position.NONE = 4; + +Position.strings = ['before', 'after', 'inside', 'none']; + +Node = (function() { + function Node(o, is_root, node_class) { + if (is_root == null) { + is_root = false; + } + if (node_class == null) { + node_class = Node; + } + this.name = ''; + this.setData(o); + this.children = []; + this.parent = null; + if (is_root) { + this.id_mapping = {}; + this.tree = this; + this.node_class = node_class; + } + } + + Node.prototype.setData = function(o) { + + /* + Set the data of this node. + + setData(string): set the name of the node + setdata(object): set attributes of the node + + Examples: + setdata('node1') + + setData({ name: 'node1', id: 1}); + + setData({ name: 'node2', id: 2, color: 'green'}); + + * This is an internal function; it is not in the docs + * Does not remove existing node values + */ + var key, setName, value; + setName = (function(_this) { + return function(name) { + if (name !== null) { + return _this.name = name; + } + }; + })(this); + if (typeof o !== 'object') { + setName(o); + } else { + for (key in o) { + value = o[key]; + if (key === 'label') { + setName(value); + } else if (key !== 'children') { + this[key] = value; + } + } + } + return null; + }; + + Node.prototype.initFromData = function(data) { + var addChildren, addNode; + addNode = (function(_this) { + return function(node_data) { + _this.setData(node_data); + if (node_data.children) { + return addChildren(node_data.children); + } + }; + })(this); + addChildren = (function(_this) { + return function(children_data) { + var child, j, len, node; + for (j = 0, len = children_data.length; j < len; j++) { + child = children_data[j]; + node = new _this.tree.node_class(''); + node.initFromData(child); + _this.addChild(node); + } + return null; + }; + })(this); + addNode(data); + return null; + }; + + + /* + Create tree from data. + + Structure of data is: + [ + { + label: 'node1', + children: [ + { label: 'child1' }, + { label: 'child2' } + ] + }, + { + label: 'node2' + } + ] + */ + + Node.prototype.loadFromData = function(data) { + var j, len, node, o; + this.removeChildren(); + for (j = 0, len = data.length; j < len; j++) { + o = data[j]; + node = new this.tree.node_class(o); + this.addChild(node); + if (typeof o === 'object' && o.children) { + node.loadFromData(o.children); + } + } + return null; + }; + + + /* + Add child. + + tree.addChild( + new Node('child1') + ); + */ + + Node.prototype.addChild = function(node) { + this.children.push(node); + return node._setParent(this); + }; + + + /* + Add child at position. Index starts at 0. + + tree.addChildAtPosition( + new Node('abc'), + 1 + ); + */ + + Node.prototype.addChildAtPosition = function(node, index) { + this.children.splice(index, 0, node); + return node._setParent(this); + }; + + Node.prototype._setParent = function(parent) { + this.parent = parent; + this.tree = parent.tree; + return this.tree.addNodeToIndex(this); + }; + + + /* + Remove child. This also removes the children of the node. + + tree.removeChild(tree.children[0]); + */ + + Node.prototype.removeChild = function(node) { + node.removeChildren(); + return this._removeChild(node); + }; + + Node.prototype._removeChild = function(node) { + this.children.splice(this.getChildIndex(node), 1); + return this.tree.removeNodeFromIndex(node); + }; + + + /* + Get child index. + + var index = getChildIndex(node); + */ + + Node.prototype.getChildIndex = function(node) { + return $.inArray(node, this.children); + }; + + + /* + Does the tree have children? + + if (tree.hasChildren()) { + // + } + */ + + Node.prototype.hasChildren = function() { + return this.children.length !== 0; + }; + + Node.prototype.isFolder = function() { + return this.hasChildren() || this.load_on_demand; + }; + + + /* + Iterate over all the nodes in the tree. + + Calls callback with (node, level). + + The callback must return true to continue the iteration on current node. + + tree.iterate( + function(node, level) { + console.log(node.name); + + // stop iteration after level 2 + return (level <= 2); + } + ); + */ + + Node.prototype.iterate = function(callback) { + var _iterate; + _iterate = function(node, level) { + var child, j, len, ref, result; + if (node.children) { + ref = node.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + result = callback(child, level); + if (result && child.hasChildren()) { + _iterate(child, level + 1); + } + } + return null; + } + }; + _iterate(this, 0); + return null; + }; + + + /* + Move node relative to another node. + + Argument position: Position.BEFORE, Position.AFTER or Position.Inside + + // move node1 after node2 + tree.moveNode(node1, node2, Position.AFTER); + */ + + Node.prototype.moveNode = function(moved_node, target_node, position) { + if (moved_node.isParentOf(target_node)) { + return; + } + moved_node.parent._removeChild(moved_node); + if (position === Position.AFTER) { + return target_node.parent.addChildAtPosition(moved_node, target_node.parent.getChildIndex(target_node) + 1); + } else if (position === Position.BEFORE) { + return target_node.parent.addChildAtPosition(moved_node, target_node.parent.getChildIndex(target_node)); + } else if (position === Position.INSIDE) { + return target_node.addChildAtPosition(moved_node, 0); + } + }; + + + /* + Get the tree as data. + */ + + Node.prototype.getData = function(include_parent) { + var getDataFromNodes; + if (include_parent == null) { + include_parent = false; + } + getDataFromNodes = function(nodes) { + var data, j, k, len, node, tmp_node, v; + data = []; + for (j = 0, len = nodes.length; j < len; j++) { + node = nodes[j]; + tmp_node = {}; + for (k in node) { + v = node[k]; + if ((k !== 'parent' && k !== 'children' && k !== 'element' && k !== 'tree') && Object.prototype.hasOwnProperty.call(node, k)) { + tmp_node[k] = v; + } + } + if (node.hasChildren()) { + tmp_node.children = getDataFromNodes(node.children); + } + data.push(tmp_node); + } + return data; + }; + if (include_parent) { + return getDataFromNodes([this]); + } else { + return getDataFromNodes(this.children); + } + }; + + Node.prototype.getNodeByName = function(name) { + return this.getNodeByCallback(function(node) { + return node.name === name; + }); + }; + + Node.prototype.getNodeByCallback = function(callback) { + var result; + result = null; + this.iterate(function(node) { + if (callback(node)) { + result = node; + return false; + } else { + return true; + } + }); + return result; + }; + + Node.prototype.addAfter = function(node_info) { + var child_index, node; + if (!this.parent) { + return null; + } else { + node = new this.tree.node_class(node_info); + child_index = this.parent.getChildIndex(this); + this.parent.addChildAtPosition(node, child_index + 1); + if (typeof node_info === 'object' && node_info.children && node_info.children.length) { + node.loadFromData(node_info.children); + } + return node; + } + }; + + Node.prototype.addBefore = function(node_info) { + var child_index, node; + if (!this.parent) { + return null; + } else { + node = new this.tree.node_class(node_info); + child_index = this.parent.getChildIndex(this); + this.parent.addChildAtPosition(node, child_index); + if (typeof node_info === 'object' && node_info.children && node_info.children.length) { + node.loadFromData(node_info.children); + } + return node; + } + }; + + Node.prototype.addParent = function(node_info) { + var child, j, len, new_parent, original_parent, ref; + if (!this.parent) { + return null; + } else { + new_parent = new this.tree.node_class(node_info); + new_parent._setParent(this.tree); + original_parent = this.parent; + ref = original_parent.children; + for (j = 0, len = ref.length; j < len; j++) { + child = ref[j]; + new_parent.addChild(child); + } + original_parent.children = []; + original_parent.addChild(new_parent); + return new_parent; + } + }; + + Node.prototype.remove = function() { + if (this.parent) { + this.parent.removeChild(this); + return this.parent = null; + } + }; + + Node.prototype.append = function(node_info) { + var node; + node = new this.tree.node_class(node_info); + this.addChild(node); + if (typeof node_info === 'object' && node_info.children && node_info.children.length) { + node.loadFromData(node_info.children); + } + return node; + }; + + Node.prototype.prepend = function(node_info) { + var node; + node = new this.tree.node_class(node_info); + this.addChildAtPosition(node, 0); + if (typeof node_info === 'object' && node_info.children && node_info.children.length) { + node.loadFromData(node_info.children); + } + return node; + }; + + Node.prototype.isParentOf = function(node) { + var parent; + parent = node.parent; + while (parent) { + if (parent === this) { + return true; + } + parent = parent.parent; + } + return false; + }; + + Node.prototype.getLevel = function() { + var level, node; + level = 0; + node = this; + while (node.parent) { + level += 1; + node = node.parent; + } + return level; + }; + + Node.prototype.getNodeById = function(node_id) { + return this.id_mapping[node_id]; + }; + + Node.prototype.addNodeToIndex = function(node) { + if (node.id != null) { + return this.id_mapping[node.id] = node; + } + }; + + Node.prototype.removeNodeFromIndex = function(node) { + if (node.id != null) { + return delete this.id_mapping[node.id]; + } + }; + + Node.prototype.removeChildren = function() { + this.iterate((function(_this) { + return function(child) { + _this.tree.removeNodeFromIndex(child); + return true; + }; + })(this)); + return this.children = []; + }; + + Node.prototype.getPreviousSibling = function() { + var previous_index; + if (!this.parent) { + return null; + } else { + previous_index = this.parent.getChildIndex(this) - 1; + if (previous_index >= 0) { + return this.parent.children[previous_index]; + } else { + return null; + } + } + }; + + Node.prototype.getNextSibling = function() { + var next_index; + if (!this.parent) { + return null; + } else { + next_index = this.parent.getChildIndex(this) + 1; + if (next_index < this.parent.children.length) { + return this.parent.children[next_index]; + } else { + return null; + } + } + }; + + Node.prototype.getNodesByProperty = function(key, value) { + return this.filter(function(node) { + return node[key] === value; + }); + }; + + Node.prototype.filter = function(f) { + var result; + result = []; + this.iterate(function(node) { + if (f(node)) { + result.push(node); + } + return true; + }); + return result; + }; + + Node.prototype.getNextNode = function(include_children) { + var next_sibling; + if (include_children == null) { + include_children = true; + } + if (include_children && this.hasChildren() && this.is_open) { + return this.children[0]; + } else { + if (!this.parent) { + return null; + } else { + next_sibling = this.getNextSibling(); + if (next_sibling) { + return next_sibling; + } else { + return this.parent.getNextNode(false); + } + } + } + }; + + Node.prototype.getPreviousNode = function() { + var previous_sibling; + if (!this.parent) { + return null; + } else { + previous_sibling = this.getPreviousSibling(); + if (previous_sibling) { + if (!previous_sibling.hasChildren() || !previous_sibling.is_open) { + return previous_sibling; + } else { + return previous_sibling.getLastChild(); + } + } else { + return this.getParent(); + } + } + }; + + Node.prototype.getParent = function() { + if (!this.parent) { + return null; + } else if (!this.parent.parent) { + return null; + } else { + return this.parent; + } + }; + + Node.prototype.getLastChild = function() { + var last_child; + if (!this.hasChildren()) { + return null; + } else { + last_child = this.children[this.children.length - 1]; + if (!last_child.hasChildren() || !last_child.is_open) { + return last_child; + } else { + return last_child.getLastChild(); + } + } + }; + + return Node; + +})(); + +module.exports = { + Node: Node, + Position: Position +}; + +},{}],6:[function(require,module,exports){ +var $, BorderDropHint, FolderElement, GhostDropHint, NodeElement, Position, node, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +node = require('./node'); + +Position = node.Position; + +$ = jQuery; + +NodeElement = (function() { + function NodeElement(node, tree_widget) { + this.init(node, tree_widget); + } + + NodeElement.prototype.init = function(node, tree_widget) { + this.node = node; + this.tree_widget = tree_widget; + if (!node.element) { + node.element = this.tree_widget.element; + } + return this.$element = $(node.element); + }; + + NodeElement.prototype.getUl = function() { + return this.$element.children('ul:first'); + }; + + NodeElement.prototype.getSpan = function() { + return this.$element.children('.jqtree-element').find('span.jqtree-title'); + }; + + NodeElement.prototype.getLi = function() { + return this.$element; + }; + + NodeElement.prototype.addDropHint = function(position) { + if (position === Position.INSIDE) { + return new BorderDropHint(this.$element); + } else { + return new GhostDropHint(this.node, this.$element, position); + } + }; + + NodeElement.prototype.select = function() { + var $li, $span; + $li = this.getLi(); + $li.addClass('jqtree-selected'); + $li.attr('aria-selected', 'true'); + $span = this.getSpan(); + return $span.attr('tabindex', 0); + }; + + NodeElement.prototype.deselect = function() { + var $li, $span; + $li = this.getLi(); + $li.removeClass('jqtree-selected'); + $li.attr('aria-selected', 'false'); + $span = this.getSpan(); + return $span.attr('tabindex', -1); + }; + + return NodeElement; + +})(); + +FolderElement = (function(superClass) { + extend(FolderElement, superClass); + + function FolderElement() { + return FolderElement.__super__.constructor.apply(this, arguments); + } + + FolderElement.prototype.open = function(on_finished, slide) { + var $button, doOpen; + if (slide == null) { + slide = true; + } + if (!this.node.is_open) { + this.node.is_open = true; + $button = this.getButton(); + $button.removeClass('jqtree-closed'); + $button.html(''); + $button.append(this.tree_widget.renderer.opened_icon_element.cloneNode(false)); + doOpen = (function(_this) { + return function() { + var $li, $span; + $li = _this.getLi(); + $li.removeClass('jqtree-closed'); + $span = _this.getSpan(); + $span.attr('aria-expanded', 'true'); + if (on_finished) { + on_finished(_this.node); + } + return _this.tree_widget._triggerEvent('tree.open', { + node: _this.node + }); + }; + })(this); + if (slide) { + return this.getUl().slideDown('fast', doOpen); + } else { + this.getUl().show(); + return doOpen(); + } + } + }; + + FolderElement.prototype.close = function(slide) { + var $button, doClose; + if (slide == null) { + slide = true; + } + if (this.node.is_open) { + this.node.is_open = false; + $button = this.getButton(); + $button.addClass('jqtree-closed'); + $button.html(''); + $button.append(this.tree_widget.renderer.closed_icon_element.cloneNode(false)); + doClose = (function(_this) { + return function() { + var $li, $span; + $li = _this.getLi(); + $li.addClass('jqtree-closed'); + $span = _this.getSpan(); + $span.attr('aria-expanded', 'false'); + return _this.tree_widget._triggerEvent('tree.close', { + node: _this.node + }); + }; + })(this); + if (slide) { + return this.getUl().slideUp('fast', doClose); + } else { + this.getUl().hide(); + return doClose(); + } + } + }; + + FolderElement.prototype.getButton = function() { + return this.$element.children('.jqtree-element').find('a.jqtree-toggler'); + }; + + FolderElement.prototype.addDropHint = function(position) { + if (!this.node.is_open && position === Position.INSIDE) { + return new BorderDropHint(this.$element); + } else { + return new GhostDropHint(this.node, this.$element, position); + } + }; + + return FolderElement; + +})(NodeElement); + +BorderDropHint = (function() { + function BorderDropHint($element) { + var $div, width; + $div = $element.children('.jqtree-element'); + width = $element.width() - 4; + this.$hint = $('<span class="jqtree-border"></span>'); + $div.append(this.$hint); + this.$hint.css({ + width: width, + height: $div.outerHeight() - 4 + }); + } + + BorderDropHint.prototype.remove = function() { + return this.$hint.remove(); + }; + + return BorderDropHint; + +})(); + +GhostDropHint = (function() { + function GhostDropHint(node, $element, position) { + this.$element = $element; + this.node = node; + this.$ghost = $('<li class="jqtree_common jqtree-ghost"><span class="jqtree_common jqtree-circle"></span><span class="jqtree_common jqtree-line"></span></li>'); + if (position === Position.AFTER) { + this.moveAfter(); + } else if (position === Position.BEFORE) { + this.moveBefore(); + } else if (position === Position.INSIDE) { + if (node.isFolder() && node.is_open) { + this.moveInsideOpenFolder(); + } else { + this.moveInside(); + } + } + } + + GhostDropHint.prototype.remove = function() { + return this.$ghost.remove(); + }; + + GhostDropHint.prototype.moveAfter = function() { + return this.$element.after(this.$ghost); + }; + + GhostDropHint.prototype.moveBefore = function() { + return this.$element.before(this.$ghost); + }; + + GhostDropHint.prototype.moveInsideOpenFolder = function() { + return $(this.node.children[0].element).before(this.$ghost); + }; + + GhostDropHint.prototype.moveInside = function() { + this.$element.after(this.$ghost); + return this.$ghost.addClass('jqtree-inside'); + }; + + return GhostDropHint; + +})(); + +module.exports = { + BorderDropHint: BorderDropHint, + FolderElement: FolderElement, + GhostDropHint: GhostDropHint, + NodeElement: NodeElement +}; + +},{"./node":5}],7:[function(require,module,exports){ +var $, SaveStateHandler, indexOf, isInt, util; + +util = require('./util'); + +indexOf = util.indexOf; + +isInt = util.isInt; + +$ = jQuery; + +SaveStateHandler = (function() { + function SaveStateHandler(tree_widget) { + this.tree_widget = tree_widget; + } + + SaveStateHandler.prototype.saveState = function() { + var state; + state = JSON.stringify(this.getState()); + if (this.tree_widget.options.onSetStateFromStorage) { + return this.tree_widget.options.onSetStateFromStorage(state); + } else if (this.supportsLocalStorage()) { + return localStorage.setItem(this.getCookieName(), state); + } else if ($.cookie) { + $.cookie.raw = true; + return $.cookie(this.getCookieName(), state, { + path: '/' + }); + } + }; + + SaveStateHandler.prototype.getStateFromStorage = function() { + var json_data; + json_data = this._loadFromStorage(); + if (json_data) { + return this._parseState(json_data); + } else { + return null; + } + }; + + SaveStateHandler.prototype._parseState = function(json_data) { + var state; + state = $.parseJSON(json_data); + if (state && state.selected_node && isInt(state.selected_node)) { + state.selected_node = [state.selected_node]; + } + return state; + }; + + SaveStateHandler.prototype._loadFromStorage = function() { + if (this.tree_widget.options.onGetStateFromStorage) { + return this.tree_widget.options.onGetStateFromStorage(); + } else if (this.supportsLocalStorage()) { + return localStorage.getItem(this.getCookieName()); + } else if ($.cookie) { + $.cookie.raw = true; + return $.cookie(this.getCookieName()); + } else { + return null; + } + }; + + SaveStateHandler.prototype.getState = function() { + var getOpenNodeIds, getSelectedNodeIds; + getOpenNodeIds = (function(_this) { + return function() { + var open_nodes; + open_nodes = []; + _this.tree_widget.tree.iterate(function(node) { + if (node.is_open && node.id && node.hasChildren()) { + open_nodes.push(node.id); + } + return true; + }); + return open_nodes; + }; + })(this); + getSelectedNodeIds = (function(_this) { + return function() { + var n; + return (function() { + var i, len, ref, results; + ref = this.tree_widget.getSelectedNodes(); + results = []; + for (i = 0, len = ref.length; i < len; i++) { + n = ref[i]; + results.push(n.id); + } + return results; + }).call(_this); + }; + })(this); + return { + open_nodes: getOpenNodeIds(), + selected_node: getSelectedNodeIds() + }; + }; + + SaveStateHandler.prototype.setInitialState = function(state) { + var must_load_on_demand; + if (!state) { + return false; + } else { + must_load_on_demand = this._openInitialNodes(state.open_nodes); + this._selectInitialNodes(state.selected_node); + return must_load_on_demand; + } + }; + + SaveStateHandler.prototype._openInitialNodes = function(node_ids) { + var i, len, must_load_on_demand, node, node_id; + must_load_on_demand = false; + for (i = 0, len = node_ids.length; i < len; i++) { + node_id = node_ids[i]; + node = this.tree_widget.getNodeById(node_id); + if (node) { + if (!node.load_on_demand) { + node.is_open = true; + } else { + must_load_on_demand = true; + } + } + } + return must_load_on_demand; + }; + + SaveStateHandler.prototype._selectInitialNodes = function(node_ids) { + var i, len, node, node_id, select_count; + select_count = 0; + for (i = 0, len = node_ids.length; i < len; i++) { + node_id = node_ids[i]; + node = this.tree_widget.getNodeById(node_id); + if (node) { + select_count += 1; + this.tree_widget.select_node_handler.addToSelection(node); + } + } + return select_count !== 0; + }; + + SaveStateHandler.prototype.setInitialStateOnDemand = function(state, cb_finished) { + if (state) { + return this._setInitialStateOnDemand(state.open_nodes, state.selected_node, cb_finished); + } else { + return cb_finished(); + } + }; + + SaveStateHandler.prototype._setInitialStateOnDemand = function(node_ids, selected_nodes, cb_finished) { + var loadAndOpenNode, loading_count, openNodes; + loading_count = 0; + openNodes = (function(_this) { + return function() { + var i, len, new_nodes_ids, node, node_id; + new_nodes_ids = []; + for (i = 0, len = node_ids.length; i < len; i++) { + node_id = node_ids[i]; + node = _this.tree_widget.getNodeById(node_id); + if (!node) { + new_nodes_ids.push(node_id); + } else { + if (!node.is_loading) { + if (node.load_on_demand) { + loadAndOpenNode(node); + } else { + _this.tree_widget._openNode(node, false); + } + } + } + } + node_ids = new_nodes_ids; + if (_this._selectInitialNodes(selected_nodes)) { + _this.tree_widget._refreshElements(); + } + if (loading_count === 0) { + return cb_finished(); + } + }; + })(this); + loadAndOpenNode = (function(_this) { + return function(node) { + loading_count += 1; + return _this.tree_widget._openNode(node, false, function() { + loading_count -= 1; + return openNodes(); + }); + }; + })(this); + return openNodes(); + }; + + SaveStateHandler.prototype.getCookieName = function() { + if (typeof this.tree_widget.options.saveState === 'string') { + return this.tree_widget.options.saveState; + } else { + return 'tree'; + } + }; + + SaveStateHandler.prototype.supportsLocalStorage = function() { + var testSupport; + testSupport = function() { + var error, key; + if (typeof localStorage === "undefined" || localStorage === null) { + return false; + } else { + try { + key = '_storage_test'; + sessionStorage.setItem(key, true); + sessionStorage.removeItem(key); + } catch (error1) { + error = error1; + return false; + } + return true; + } + }; + if (this._supportsLocalStorage == null) { + this._supportsLocalStorage = testSupport(); + } + return this._supportsLocalStorage; + }; + + SaveStateHandler.prototype.getNodeIdToBeSelected = function() { + var state; + state = this.getStateFromStorage(); + if (state && state.selected_node) { + return state.selected_node[0]; + } else { + return null; + } + }; + + return SaveStateHandler; + +})(); + +module.exports = SaveStateHandler; + +},{"./util":12}],8:[function(require,module,exports){ +var $, ScrollHandler; + +$ = jQuery; + +ScrollHandler = (function() { + function ScrollHandler(tree_widget) { + this.tree_widget = tree_widget; + this.previous_top = -1; + this.is_initialized = false; + } + + ScrollHandler.prototype._initScrollParent = function() { + var $scroll_parent, getParentWithOverflow, setDocumentAsScrollParent; + getParentWithOverflow = (function(_this) { + return function() { + var css_values, el, hasOverFlow, i, len, ref; + css_values = ['overflow', 'overflow-y']; + hasOverFlow = function(el) { + var css_value, i, len, ref; + for (i = 0, len = css_values.length; i < len; i++) { + css_value = css_values[i]; + if ((ref = $.css(el, css_value)) === 'auto' || ref === 'scroll') { + return true; + } + } + return false; + }; + if (hasOverFlow(_this.tree_widget.$el[0])) { + return _this.tree_widget.$el; + } + ref = _this.tree_widget.$el.parents(); + for (i = 0, len = ref.length; i < len; i++) { + el = ref[i]; + if (hasOverFlow(el)) { + return $(el); + } + } + return null; + }; + })(this); + setDocumentAsScrollParent = (function(_this) { + return function() { + _this.scroll_parent_top = 0; + return _this.$scroll_parent = null; + }; + })(this); + if (this.tree_widget.$el.css('position') === 'fixed') { + setDocumentAsScrollParent(); + } + $scroll_parent = getParentWithOverflow(); + if ($scroll_parent && $scroll_parent.length && $scroll_parent[0].tagName !== 'HTML') { + this.$scroll_parent = $scroll_parent; + this.scroll_parent_top = this.$scroll_parent.offset().top; + } else { + setDocumentAsScrollParent(); + } + return this.is_initialized = true; + }; + + ScrollHandler.prototype._ensureInit = function() { + if (!this.is_initialized) { + return this._initScrollParent(); + } + }; + + ScrollHandler.prototype.checkScrolling = function() { + var hovered_area; + this._ensureInit(); + hovered_area = this.tree_widget.dnd_handler.hovered_area; + if (hovered_area && hovered_area.top !== this.previous_top) { + this.previous_top = hovered_area.top; + if (this.$scroll_parent) { + return this._handleScrollingWithScrollParent(hovered_area); + } else { + return this._handleScrollingWithDocument(hovered_area); + } + } + }; + + ScrollHandler.prototype._handleScrollingWithScrollParent = function(area) { + var distance_bottom; + distance_bottom = this.scroll_parent_top + this.$scroll_parent[0].offsetHeight - area.bottom; + if (distance_bottom < 20) { + this.$scroll_parent[0].scrollTop += 20; + this.tree_widget.refreshHitAreas(); + return this.previous_top = -1; + } else if ((area.top - this.scroll_parent_top) < 20) { + this.$scroll_parent[0].scrollTop -= 20; + this.tree_widget.refreshHitAreas(); + return this.previous_top = -1; + } + }; + + ScrollHandler.prototype._handleScrollingWithDocument = function(area) { + var distance_top; + distance_top = area.top - $(document).scrollTop(); + if (distance_top < 20) { + return $(document).scrollTop($(document).scrollTop() - 20); + } else if ($(window).height() - (area.bottom - $(document).scrollTop()) < 20) { + return $(document).scrollTop($(document).scrollTop() + 20); + } + }; + + ScrollHandler.prototype.scrollTo = function(top) { + var tree_top; + this._ensureInit(); + if (this.$scroll_parent) { + return this.$scroll_parent[0].scrollTop = top; + } else { + tree_top = this.tree_widget.$el.offset().top; + return $(document).scrollTop(top + tree_top); + } + }; + + ScrollHandler.prototype.isScrolledIntoView = function(element) { + var $element, element_bottom, element_top, view_bottom, view_top; + this._ensureInit(); + $element = $(element); + if (this.$scroll_parent) { + view_top = 0; + view_bottom = this.$scroll_parent.height(); + element_top = $element.offset().top - this.scroll_parent_top; + element_bottom = element_top + $element.height(); + } else { + view_top = $(window).scrollTop(); + view_bottom = view_top + $(window).height(); + element_top = $element.offset().top; + element_bottom = element_top + $element.height(); + } + return (element_bottom <= view_bottom) && (element_top >= view_top); + }; + + return ScrollHandler; + +})(); + +module.exports = ScrollHandler; + +},{}],9:[function(require,module,exports){ +var $, SelectNodeHandler; + +$ = jQuery; + +SelectNodeHandler = (function() { + function SelectNodeHandler(tree_widget) { + this.tree_widget = tree_widget; + this.clear(); + } + + SelectNodeHandler.prototype.getSelectedNode = function() { + var selected_nodes; + selected_nodes = this.getSelectedNodes(); + if (selected_nodes.length) { + return selected_nodes[0]; + } else { + return false; + } + }; + + SelectNodeHandler.prototype.getSelectedNodes = function() { + var id, node, selected_nodes; + if (this.selected_single_node) { + return [this.selected_single_node]; + } else { + selected_nodes = []; + for (id in this.selected_nodes) { + node = this.tree_widget.getNodeById(id); + if (node) { + selected_nodes.push(node); + } + } + return selected_nodes; + } + }; + + SelectNodeHandler.prototype.getSelectedNodesUnder = function(parent) { + var id, node, selected_nodes; + if (this.selected_single_node) { + if (parent.isParentOf(this.selected_single_node)) { + return [this.selected_single_node]; + } else { + return []; + } + } else { + selected_nodes = []; + for (id in this.selected_nodes) { + node = this.tree_widget.getNodeById(id); + if (node && parent.isParentOf(node)) { + selected_nodes.push(node); + } + } + return selected_nodes; + } + }; + + SelectNodeHandler.prototype.isNodeSelected = function(node) { + if (!node) { + return false; + } else if (node.id) { + if (this.selected_nodes[node.id]) { + return true; + } else { + return false; + } + } else if (this.selected_single_node) { + return this.selected_single_node.element === node.element; + } else { + return false; + } + }; + + SelectNodeHandler.prototype.clear = function() { + this.selected_nodes = {}; + return this.selected_single_node = null; + }; + + SelectNodeHandler.prototype.removeFromSelection = function(node, include_children) { + if (include_children == null) { + include_children = false; + } + if (!node.id) { + if (this.selected_single_node && node.element === this.selected_single_node.element) { + return this.selected_single_node = null; + } + } else { + delete this.selected_nodes[node.id]; + if (include_children) { + return node.iterate((function(_this) { + return function(n) { + delete _this.selected_nodes[node.id]; + return true; + }; + })(this)); + } + } + }; + + SelectNodeHandler.prototype.addToSelection = function(node) { + if (node.id) { + return this.selected_nodes[node.id] = true; + } else { + return this.selected_single_node = node; + } + }; + + return SelectNodeHandler; + +})(); + +module.exports = SelectNodeHandler; + +},{}],10:[function(require,module,exports){ + +/* +Copyright 2013 Marco Braak + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + */ +var $, SimpleWidget, + slice = [].slice; + +$ = jQuery; + +SimpleWidget = (function() { + SimpleWidget.prototype.defaults = {}; + + function SimpleWidget(el, options) { + this.$el = $(el); + this.options = $.extend({}, this.defaults, options); + } + + SimpleWidget.prototype.destroy = function() { + return this._deinit(); + }; + + SimpleWidget.prototype._init = function() { + return null; + }; + + SimpleWidget.prototype._deinit = function() { + return null; + }; + + SimpleWidget.register = function(widget_class, widget_name) { + var callFunction, createWidget, destroyWidget, getDataKey, getWidgetData; + getDataKey = function() { + return "simple_widget_" + widget_name; + }; + getWidgetData = function(el, data_key) { + var widget; + widget = $.data(el, data_key); + if (widget && (widget instanceof SimpleWidget)) { + return widget; + } else { + return null; + } + }; + createWidget = function($el, options) { + var data_key, el, existing_widget, i, len, widget; + data_key = getDataKey(); + for (i = 0, len = $el.length; i < len; i++) { + el = $el[i]; + existing_widget = getWidgetData(el, data_key); + if (!existing_widget) { + widget = new widget_class(el, options); + if (!$.data(el, data_key)) { + $.data(el, data_key, widget); + } + widget._init(); + } + } + return $el; + }; + destroyWidget = function($el) { + var data_key, el, i, len, results, widget; + data_key = getDataKey(); + results = []; + for (i = 0, len = $el.length; i < len; i++) { + el = $el[i]; + widget = getWidgetData(el, data_key); + if (widget) { + widget.destroy(); + } + results.push($.removeData(el, data_key)); + } + return results; + }; + callFunction = function($el, function_name, args) { + var el, i, len, result, widget, widget_function; + result = null; + for (i = 0, len = $el.length; i < len; i++) { + el = $el[i]; + widget = $.data(el, getDataKey()); + if (widget && (widget instanceof SimpleWidget)) { + widget_function = widget[function_name]; + if (widget_function && (typeof widget_function === 'function')) { + result = widget_function.apply(widget, args); + } + } + } + return result; + }; + return $.fn[widget_name] = function() { + var $el, args, argument1, function_name, options; + argument1 = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : []; + $el = this; + if (argument1 === void 0 || typeof argument1 === 'object') { + options = argument1; + return createWidget($el, options); + } else if (typeof argument1 === 'string' && argument1[0] !== '_') { + function_name = argument1; + if (function_name === 'destroy') { + return destroyWidget($el); + } else if (function_name === 'get_widget_class') { + return widget_class; + } else { + return callFunction($el, function_name, args); + } + } + }; + }; + + return SimpleWidget; + +})(); + +module.exports = SimpleWidget; + +},{}],11:[function(require,module,exports){ +var $, BorderDropHint, DragAndDropHandler, DragElement, ElementsRenderer, FolderElement, GhostDropHint, HitAreasGenerator, JqTreeWidget, KeyHandler, MouseWidget, Node, NodeElement, Position, SaveStateHandler, ScrollHandler, SelectNodeHandler, SimpleWidget, __version__, drag_and_drop_handler, isFunction, node_module, ref, util_module, + extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, + hasProp = {}.hasOwnProperty; + +__version__ = require('./version'); + +drag_and_drop_handler = require('./drag_and_drop_handler'); + +ElementsRenderer = require('./elements_renderer'); + +KeyHandler = require('./key_handler'); + +MouseWidget = require('./mouse.widget'); + +SaveStateHandler = require('./save_state_handler'); + +ScrollHandler = require('./scroll_handler'); + +SelectNodeHandler = require('./select_node_handler'); + +SimpleWidget = require('./simple.widget'); + +node_module = require('./node'); + +Node = node_module.Node; + +Position = node_module.Position; + +util_module = require('./util'); + +isFunction = util_module.isFunction; + +ref = require('./node_element'), BorderDropHint = ref.BorderDropHint, FolderElement = ref.FolderElement, GhostDropHint = ref.GhostDropHint, NodeElement = ref.NodeElement; + +DragAndDropHandler = drag_and_drop_handler.DragAndDropHandler, DragElement = drag_and_drop_handler.DragElement, HitAreasGenerator = drag_and_drop_handler.HitAreasGenerator; + +$ = jQuery; + +JqTreeWidget = (function(superClass) { + extend(JqTreeWidget, superClass); + + function JqTreeWidget() { + return JqTreeWidget.__super__.constructor.apply(this, arguments); + } + + JqTreeWidget.prototype.BorderDropHint = BorderDropHint; + + JqTreeWidget.prototype.DragElement = DragElement; + + JqTreeWidget.prototype.DragAndDropHandler = DragAndDropHandler; + + JqTreeWidget.prototype.ElementsRenderer = ElementsRenderer; + + JqTreeWidget.prototype.GhostDropHint = GhostDropHint; + + JqTreeWidget.prototype.HitAreasGenerator = HitAreasGenerator; + + JqTreeWidget.prototype.Node = Node; + + JqTreeWidget.prototype.SaveStateHandler = SaveStateHandler; + + JqTreeWidget.prototype.ScrollHandler = ScrollHandler; + + JqTreeWidget.prototype.SelectNodeHandler = SelectNodeHandler; + + JqTreeWidget.prototype.defaults = { + autoOpen: false, + saveState: false, + dragAndDrop: false, + selectable: true, + useContextMenu: true, + onCanSelectNode: null, + onSetStateFromStorage: null, + onGetStateFromStorage: null, + onCreateLi: null, + onIsMoveHandle: null, + onCanMove: null, + onCanMoveTo: null, + onLoadFailed: null, + autoEscape: true, + dataUrl: null, + closedIcon: null, + openedIcon: '▼', + slide: true, + nodeClass: Node, + dataFilter: null, + keyboardSupport: true, + openFolderDelay: 500, + rtl: null, + onDragMove: null, + onDragStop: null, + buttonLeft: true, + onLoading: null + }; + + JqTreeWidget.prototype.toggle = function(node, slide) { + if (slide == null) { + slide = null; + } + if (slide === null) { + slide = this.options.slide; + } + if (node.is_open) { + this.closeNode(node, slide); + } else { + this.openNode(node, slide); + } + return this.element; + }; + + JqTreeWidget.prototype.getTree = function() { + return this.tree; + }; + + JqTreeWidget.prototype.selectNode = function(node) { + this._selectNode(node, false); + return this.element; + }; + + JqTreeWidget.prototype._selectNode = function(node, must_toggle) { + var canSelect, deselected_node, openParents, saveState; + if (must_toggle == null) { + must_toggle = false; + } + if (!this.select_node_handler) { + return; + } + canSelect = (function(_this) { + return function() { + if (_this.options.onCanSelectNode) { + return _this.options.selectable && _this.options.onCanSelectNode(node); + } else { + return _this.options.selectable; + } + }; + })(this); + openParents = (function(_this) { + return function() { + var parent; + parent = node.parent; + if (parent && parent.parent && !parent.is_open) { + return _this.openNode(parent, false); + } + }; + })(this); + saveState = (function(_this) { + return function() { + if (_this.options.saveState) { + return _this.save_state_handler.saveState(); + } + }; + })(this); + if (!node) { + this._deselectCurrentNode(); + saveState(); + return; + } + if (!canSelect()) { + return; + } + if (this.select_node_handler.isNodeSelected(node)) { + if (must_toggle) { + this._deselectCurrentNode(); + this._triggerEvent('tree.select', { + node: null, + previous_node: node + }); + } + } else { + deselected_node = this.getSelectedNode(); + this._deselectCurrentNode(); + this.addToSelection(node); + this._triggerEvent('tree.select', { + node: node, + deselected_node: deselected_node + }); + openParents(); + } + return saveState(); + }; + + JqTreeWidget.prototype.getSelectedNode = function() { + if (this.select_node_handler) { + return this.select_node_handler.getSelectedNode(); + } else { + return null; + } + }; + + JqTreeWidget.prototype.toJson = function() { + return JSON.stringify(this.tree.getData()); + }; + + JqTreeWidget.prototype.loadData = function(data, parent_node) { + this._loadData(data, parent_node); + return this.element; + }; + + + /* + signatures: + - loadDataFromUrl(url, parent_node=null, on_finished=null) + loadDataFromUrl('/my_data'); + loadDataFromUrl('/my_data', node1); + loadDataFromUrl('/my_data', node1, function() { console.log('finished'); }); + loadDataFromUrl('/my_data', null, function() { console.log('finished'); }); + + - loadDataFromUrl(parent_node=null, on_finished=null) + loadDataFromUrl(); + loadDataFromUrl(node1); + loadDataFromUrl(null, function() { console.log('finished'); }); + loadDataFromUrl(node1, function() { console.log('finished'); }); + */ + + JqTreeWidget.prototype.loadDataFromUrl = function(param1, param2, param3) { + if ($.type(param1) === 'string') { + this._loadDataFromUrl(param1, param2, param3); + } else { + this._loadDataFromUrl(null, param1, param2); + } + return this.element; + }; + + JqTreeWidget.prototype.reload = function(on_finished) { + this._loadDataFromUrl(null, null, on_finished); + return this.element; + }; + + JqTreeWidget.prototype._loadDataFromUrl = function(url_info, parent_node, on_finished) { + var $el, addLoadingClass, handeLoadData, handleError, handleSuccess, loadDataFromUrlInfo, parseUrlInfo, removeLoadingClass; + $el = null; + addLoadingClass = (function(_this) { + return function() { + if (parent_node) { + $el = $(parent_node.element); + } else { + $el = _this.element; + } + $el.addClass('jqtree-loading'); + return _this._notifyLoading(true, parent_node, $el); + }; + })(this); + removeLoadingClass = (function(_this) { + return function() { + if ($el) { + $el.removeClass('jqtree-loading'); + return _this._notifyLoading(false, parent_node, $el); + } + }; + })(this); + parseUrlInfo = function() { + if ($.type(url_info) === 'string') { + return { + url: url_info + }; + } + if (!url_info.method) { + url_info.method = 'get'; + } + return url_info; + }; + handeLoadData = (function(_this) { + return function(data) { + removeLoadingClass(); + _this._loadData(data, parent_node); + if (on_finished && $.isFunction(on_finished)) { + return on_finished(); + } + }; + })(this); + handleSuccess = (function(_this) { + return function(response) { + var data; + if ($.isArray(response) || typeof response === 'object') { + data = response; + } else if (data != null) { + data = $.parseJSON(response); + } else { + data = []; + } + if (_this.options.dataFilter) { + data = _this.options.dataFilter(data); + } + return handeLoadData(data); + }; + })(this); + handleError = (function(_this) { + return function(response) { + removeLoadingClass(); + if (_this.options.onLoadFailed) { + return _this.options.onLoadFailed(response); + } + }; + })(this); + loadDataFromUrlInfo = function() { + url_info = parseUrlInfo(); + return $.ajax($.extend({}, url_info, { + method: url_info.method != null ? url_info.method.toUpperCase() : 'GET', + cache: false, + dataType: 'json', + success: handleSuccess, + error: handleError + })); + }; + if (!url_info) { + url_info = this._getDataUrlInfo(parent_node); + } + addLoadingClass(); + if (!url_info) { + removeLoadingClass(); + } else if ($.isArray(url_info)) { + handeLoadData(url_info); + } else { + loadDataFromUrlInfo(); + } + }; + + JqTreeWidget.prototype._loadData = function(data, parent_node) { + var deselectNodes, loadSubtree; + if (parent_node == null) { + parent_node = null; + } + deselectNodes = (function(_this) { + return function() { + var i, len, n, selected_nodes_under_parent; + if (_this.select_node_handler) { + selected_nodes_under_parent = _this.select_node_handler.getSelectedNodesUnder(parent_node); + for (i = 0, len = selected_nodes_under_parent.length; i < len; i++) { + n = selected_nodes_under_parent[i]; + _this.select_node_handler.removeFromSelection(n); + } + } + return null; + }; + })(this); + loadSubtree = (function(_this) { + return function() { + parent_node.loadFromData(data); + parent_node.load_on_demand = false; + parent_node.is_loading = false; + return _this._refreshElements(parent_node); + }; + })(this); + if (!data) { + return; + } + this._triggerEvent('tree.load_data', { + tree_data: data + }); + if (!parent_node) { + this._initTree(data); + } else { + deselectNodes(); + loadSubtree(); + } + if (this.isDragging()) { + return this.dnd_handler.refresh(); + } + }; + + JqTreeWidget.prototype.getNodeById = function(node_id) { + return this.tree.getNodeById(node_id); + }; + + JqTreeWidget.prototype.getNodeByName = function(name) { + return this.tree.getNodeByName(name); + }; + + JqTreeWidget.prototype.getNodesByProperty = function(key, value) { + return this.tree.getNodesByProperty(key, value); + }; + + JqTreeWidget.prototype.getNodeByHtmlElement = function(element) { + return this._getNode($(element)); + }; + + JqTreeWidget.prototype.getNodeByCallback = function(callback) { + return this.tree.getNodeByCallback(callback); + }; + + JqTreeWidget.prototype.openNode = function(node, slide_param, on_finished_param) { + var on_finished, parseParams, ref1, slide; + if (slide_param == null) { + slide_param = null; + } + if (on_finished_param == null) { + on_finished_param = null; + } + parseParams = (function(_this) { + return function() { + var on_finished, slide; + if (isFunction(slide_param)) { + on_finished = slide_param; + slide = null; + } else { + slide = slide_param; + on_finished = on_finished_param; + } + if (slide === null) { + slide = _this.options.slide; + } + return [slide, on_finished]; + }; + })(this); + ref1 = parseParams(), slide = ref1[0], on_finished = ref1[1]; + if (node) { + this._openNode(node, slide, on_finished); + } + return this.element; + }; + + JqTreeWidget.prototype._openNode = function(node, slide, on_finished) { + var doOpenNode, parent; + if (slide == null) { + slide = true; + } + doOpenNode = (function(_this) { + return function(_node, _slide, _on_finished) { + var folder_element; + folder_element = new FolderElement(_node, _this); + return folder_element.open(_on_finished, _slide); + }; + })(this); + if (node.isFolder()) { + if (node.load_on_demand) { + return this._loadFolderOnDemand(node, slide, on_finished); + } else { + parent = node.parent; + while (parent) { + if (parent.parent) { + doOpenNode(parent, false, null); + } + parent = parent.parent; + } + doOpenNode(node, slide, on_finished); + return this._saveState(); + } + } + }; + + JqTreeWidget.prototype._loadFolderOnDemand = function(node, slide, on_finished) { + if (slide == null) { + slide = true; + } + node.is_loading = true; + return this._loadDataFromUrl(null, node, (function(_this) { + return function() { + return _this._openNode(node, slide, on_finished); + }; + })(this)); + }; + + JqTreeWidget.prototype.closeNode = function(node, slide) { + if (slide == null) { + slide = null; + } + if (slide === null) { + slide = this.options.slide; + } + if (node.isFolder()) { + new FolderElement(node, this).close(slide); + this._saveState(); + } + return this.element; + }; + + JqTreeWidget.prototype.isDragging = function() { + if (this.dnd_handler) { + return this.dnd_handler.is_dragging; + } else { + return false; + } + }; + + JqTreeWidget.prototype.refreshHitAreas = function() { + this.dnd_handler.refresh(); + return this.element; + }; + + JqTreeWidget.prototype.addNodeAfter = function(new_node_info, existing_node) { + var new_node; + new_node = existing_node.addAfter(new_node_info); + this._refreshElements(existing_node.parent); + return new_node; + }; + + JqTreeWidget.prototype.addNodeBefore = function(new_node_info, existing_node) { + var new_node; + new_node = existing_node.addBefore(new_node_info); + this._refreshElements(existing_node.parent); + return new_node; + }; + + JqTreeWidget.prototype.addParentNode = function(new_node_info, existing_node) { + var new_node; + new_node = existing_node.addParent(new_node_info); + this._refreshElements(new_node.parent); + return new_node; + }; + + JqTreeWidget.prototype.removeNode = function(node) { + var parent; + parent = node.parent; + if (parent) { + this.select_node_handler.removeFromSelection(node, true); + node.remove(); + this._refreshElements(parent); + } + return this.element; + }; + + JqTreeWidget.prototype.appendNode = function(new_node_info, parent_node) { + var node; + parent_node = parent_node || this.tree; + node = parent_node.append(new_node_info); + this._refreshElements(parent_node); + return node; + }; + + JqTreeWidget.prototype.prependNode = function(new_node_info, parent_node) { + var node; + if (!parent_node) { + parent_node = this.tree; + } + node = parent_node.prepend(new_node_info); + this._refreshElements(parent_node); + return node; + }; + + JqTreeWidget.prototype.updateNode = function(node, data) { + var id_is_changed; + id_is_changed = data.id && data.id !== node.id; + if (id_is_changed) { + this.tree.removeNodeFromIndex(node); + } + node.setData(data); + if (id_is_changed) { + this.tree.addNodeToIndex(node); + } + if (typeof data === 'object' && data.children) { + node.removeChildren(); + if (data.children.length) { + node.loadFromData(data.children); + } + } + this.renderer.renderFromNode(node); + this._selectCurrentNode(); + return this.element; + }; + + JqTreeWidget.prototype.moveNode = function(node, target_node, position) { + var position_index; + position_index = Position.nameToIndex(position); + this.tree.moveNode(node, target_node, position_index); + this._refreshElements(); + return this.element; + }; + + JqTreeWidget.prototype.getStateFromStorage = function() { + return this.save_state_handler.getStateFromStorage(); + }; + + JqTreeWidget.prototype.addToSelection = function(node) { + if (node) { + this.select_node_handler.addToSelection(node); + this._getNodeElementForNode(node).select(); + this._saveState(); + } + return this.element; + }; + + JqTreeWidget.prototype.getSelectedNodes = function() { + return this.select_node_handler.getSelectedNodes(); + }; + + JqTreeWidget.prototype.isNodeSelected = function(node) { + return this.select_node_handler.isNodeSelected(node); + }; + + JqTreeWidget.prototype.removeFromSelection = function(node) { + this.select_node_handler.removeFromSelection(node); + this._getNodeElementForNode(node).deselect(); + this._saveState(); + return this.element; + }; + + JqTreeWidget.prototype.scrollToNode = function(node) { + var $element, top; + $element = $(node.element); + top = $element.offset().top - this.$el.offset().top; + this.scroll_handler.scrollTo(top); + return this.element; + }; + + JqTreeWidget.prototype.getState = function() { + return this.save_state_handler.getState(); + }; + + JqTreeWidget.prototype.setState = function(state) { + this.save_state_handler.setInitialState(state); + this._refreshElements(); + return this.element; + }; + + JqTreeWidget.prototype.setOption = function(option, value) { + this.options[option] = value; + return this.element; + }; + + JqTreeWidget.prototype.moveDown = function() { + if (this.key_handler) { + this.key_handler.moveDown(); + } + return this.element; + }; + + JqTreeWidget.prototype.moveUp = function() { + if (this.key_handler) { + this.key_handler.moveUp(); + } + return this.element; + }; + + JqTreeWidget.prototype.getVersion = function() { + return __version__; + }; + + JqTreeWidget.prototype._init = function() { + JqTreeWidget.__super__._init.call(this); + this.element = this.$el; + this.mouse_delay = 300; + this.is_initialized = false; + this.options.rtl = this._getRtlOption(); + if (!this.options.closedIcon) { + this.options.closedIcon = this._getDefaultClosedIcon(); + } + this.renderer = new ElementsRenderer(this); + if (SaveStateHandler != null) { + this.save_state_handler = new SaveStateHandler(this); + } else { + this.options.saveState = false; + } + if (SelectNodeHandler != null) { + this.select_node_handler = new SelectNodeHandler(this); + } + if (DragAndDropHandler != null) { + this.dnd_handler = new DragAndDropHandler(this); + } else { + this.options.dragAndDrop = false; + } + if (ScrollHandler != null) { + this.scroll_handler = new ScrollHandler(this); + } + if ((KeyHandler != null) && (SelectNodeHandler != null)) { + this.key_handler = new KeyHandler(this); + } + this._initData(); + this.element.click($.proxy(this._click, this)); + this.element.dblclick($.proxy(this._dblclick, this)); + if (this.options.useContextMenu) { + return this.element.bind('contextmenu', $.proxy(this._contextmenu, this)); + } + }; + + JqTreeWidget.prototype._deinit = function() { + this.element.empty(); + this.element.unbind(); + if (this.key_handler) { + this.key_handler.deinit(); + } + this.tree = null; + return JqTreeWidget.__super__._deinit.call(this); + }; + + JqTreeWidget.prototype._initData = function() { + var data_url; + if (this.options.data) { + return this._loadData(this.options.data); + } else { + data_url = this._getDataUrlInfo(); + if (data_url) { + return this._loadDataFromUrl(); + } else { + return this._loadData([]); + } + } + }; + + JqTreeWidget.prototype._getDataUrlInfo = function(node) { + var data_url, getUrlFromString; + data_url = this.options.dataUrl || this.element.data('url'); + getUrlFromString = (function(_this) { + return function() { + var data, selected_node_id, url_info; + url_info = { + url: data_url + }; + if (node && node.id) { + data = { + node: node.id + }; + url_info['data'] = data; + } else { + selected_node_id = _this._getNodeIdToBeSelected(); + if (selected_node_id) { + data = { + selected_node: selected_node_id + }; + url_info['data'] = data; + } + } + return url_info; + }; + })(this); + if ($.isFunction(data_url)) { + return data_url(node); + } else if ($.type(data_url) === 'string') { + return getUrlFromString(); + } else { + return data_url; + } + }; + + JqTreeWidget.prototype._getNodeIdToBeSelected = function() { + if (this.options.saveState) { + return this.save_state_handler.getNodeIdToBeSelected(); + } else { + return null; + } + }; + + JqTreeWidget.prototype._initTree = function(data) { + var doInit, must_load_on_demand; + doInit = (function(_this) { + return function() { + if (!_this.is_initialized) { + _this.is_initialized = true; + return _this._triggerEvent('tree.init'); + } + }; + })(this); + this.tree = new this.options.nodeClass(null, true, this.options.nodeClass); + if (this.select_node_handler) { + this.select_node_handler.clear(); + } + this.tree.loadFromData(data); + must_load_on_demand = this._setInitialState(); + this._refreshElements(); + if (!must_load_on_demand) { + return doInit(); + } else { + return this._setInitialStateOnDemand(doInit); + } + }; + + JqTreeWidget.prototype._setInitialState = function() { + var autoOpenNodes, is_restored, must_load_on_demand, ref1, restoreState; + restoreState = (function(_this) { + return function() { + var must_load_on_demand, state; + if (!(_this.options.saveState && _this.save_state_handler)) { + return [false, false]; + } else { + state = _this.save_state_handler.getStateFromStorage(); + if (!state) { + return [false, false]; + } else { + must_load_on_demand = _this.save_state_handler.setInitialState(state); + return [true, must_load_on_demand]; + } + } + }; + })(this); + autoOpenNodes = (function(_this) { + return function() { + var max_level, must_load_on_demand; + if (_this.options.autoOpen === false) { + return false; + } + max_level = _this._getAutoOpenMaxLevel(); + must_load_on_demand = false; + _this.tree.iterate(function(node, level) { + if (node.load_on_demand) { + must_load_on_demand = true; + return false; + } else if (!node.hasChildren()) { + return false; + } else { + node.is_open = true; + return level !== max_level; + } + }); + return must_load_on_demand; + }; + })(this); + ref1 = restoreState(), is_restored = ref1[0], must_load_on_demand = ref1[1]; + if (!is_restored) { + must_load_on_demand = autoOpenNodes(); + } + return must_load_on_demand; + }; + + JqTreeWidget.prototype._setInitialStateOnDemand = function(cb_finished) { + var autoOpenNodes, restoreState; + restoreState = (function(_this) { + return function() { + var state; + if (!(_this.options.saveState && _this.save_state_handler)) { + return false; + } else { + state = _this.save_state_handler.getStateFromStorage(); + if (!state) { + return false; + } else { + _this.save_state_handler.setInitialStateOnDemand(state, cb_finished); + return true; + } + } + }; + })(this); + autoOpenNodes = (function(_this) { + return function() { + var loadAndOpenNode, loading_count, max_level, openNodes; + max_level = _this._getAutoOpenMaxLevel(); + loading_count = 0; + loadAndOpenNode = function(node) { + loading_count += 1; + return _this._openNode(node, false, function() { + loading_count -= 1; + return openNodes(); + }); + }; + openNodes = function() { + _this.tree.iterate(function(node, level) { + if (node.load_on_demand) { + if (!node.is_loading) { + loadAndOpenNode(node); + } + return false; + } else { + _this._openNode(node, false); + return level !== max_level; + } + }); + if (loading_count === 0) { + return cb_finished(); + } + }; + return openNodes(); + }; + })(this); + if (!restoreState()) { + return autoOpenNodes(); + } + }; + + JqTreeWidget.prototype._getAutoOpenMaxLevel = function() { + if (this.options.autoOpen === true) { + return -1; + } else { + return parseInt(this.options.autoOpen); + } + }; + + + /* + Redraw the tree or part of the tree. + * from_node: redraw this subtree + */ + + JqTreeWidget.prototype._refreshElements = function(from_node) { + if (from_node == null) { + from_node = null; + } + this.renderer.render(from_node); + return this._triggerEvent('tree.refresh'); + }; + + JqTreeWidget.prototype._click = function(e) { + var click_target, event, node; + click_target = this._getClickTarget(e.target); + if (click_target) { + if (click_target.type === 'button') { + this.toggle(click_target.node, this.options.slide); + e.preventDefault(); + return e.stopPropagation(); + } else if (click_target.type === 'label') { + node = click_target.node; + event = this._triggerEvent('tree.click', { + node: node, + click_event: e + }); + if (!event.isDefaultPrevented()) { + return this._selectNode(node, true); + } + } + } + }; + + JqTreeWidget.prototype._dblclick = function(e) { + var click_target; + click_target = this._getClickTarget(e.target); + if (click_target && click_target.type === 'label') { + return this._triggerEvent('tree.dblclick', { + node: click_target.node, + click_event: e + }); + } + }; + + JqTreeWidget.prototype._getClickTarget = function(element) { + var $button, $el, $target, node; + $target = $(element); + $button = $target.closest('.jqtree-toggler'); + if ($button.length) { + node = this._getNode($button); + if (node) { + return { + type: 'button', + node: node + }; + } + } else { + $el = $target.closest('.jqtree-element'); + if ($el.length) { + node = this._getNode($el); + if (node) { + return { + type: 'label', + node: node + }; + } + } + } + return null; + }; + + JqTreeWidget.prototype._getNode = function($element) { + var $li; + $li = $element.closest('li.jqtree_common'); + if ($li.length === 0) { + return null; + } else { + return $li.data('node'); + } + }; + + JqTreeWidget.prototype._getNodeElementForNode = function(node) { + if (node.isFolder()) { + return new FolderElement(node, this); + } else { + return new NodeElement(node, this); + } + }; + + JqTreeWidget.prototype._getNodeElement = function($element) { + var node; + node = this._getNode($element); + if (node) { + return this._getNodeElementForNode(node); + } else { + return null; + } + }; + + JqTreeWidget.prototype._contextmenu = function(e) { + var $div, node; + $div = $(e.target).closest('ul.jqtree-tree .jqtree-element'); + if ($div.length) { + node = this._getNode($div); + if (node) { + e.preventDefault(); + e.stopPropagation(); + this._triggerEvent('tree.contextmenu', { + node: node, + click_event: e + }); + return false; + } + } + }; + + JqTreeWidget.prototype._saveState = function() { + if (this.options.saveState) { + return this.save_state_handler.saveState(); + } + }; + + JqTreeWidget.prototype._mouseCapture = function(position_info) { + if (this.options.dragAndDrop) { + return this.dnd_handler.mouseCapture(position_info); + } else { + return false; + } + }; + + JqTreeWidget.prototype._mouseStart = function(position_info) { + if (this.options.dragAndDrop) { + return this.dnd_handler.mouseStart(position_info); + } else { + return false; + } + }; + + JqTreeWidget.prototype._mouseDrag = function(position_info) { + var result; + if (this.options.dragAndDrop) { + result = this.dnd_handler.mouseDrag(position_info); + if (this.scroll_handler) { + this.scroll_handler.checkScrolling(); + } + return result; + } else { + return false; + } + }; + + JqTreeWidget.prototype._mouseStop = function(position_info) { + if (this.options.dragAndDrop) { + return this.dnd_handler.mouseStop(position_info); + } else { + return false; + } + }; + + JqTreeWidget.prototype._triggerEvent = function(event_name, values) { + var event; + event = $.Event(event_name); + $.extend(event, values); + this.element.trigger(event); + return event; + }; + + JqTreeWidget.prototype.testGenerateHitAreas = function(moving_node) { + this.dnd_handler.current_item = this._getNodeElementForNode(moving_node); + this.dnd_handler.generateHitAreas(); + return this.dnd_handler.hit_areas; + }; + + JqTreeWidget.prototype._selectCurrentNode = function() { + var node, node_element; + node = this.getSelectedNode(); + if (node) { + node_element = this._getNodeElementForNode(node); + if (node_element) { + return node_element.select(); + } + } + }; + + JqTreeWidget.prototype._deselectCurrentNode = function() { + var node; + node = this.getSelectedNode(); + if (node) { + return this.removeFromSelection(node); + } + }; + + JqTreeWidget.prototype._getDefaultClosedIcon = function() { + if (this.options.rtl) { + return '◀'; + } else { + return '►'; + } + }; + + JqTreeWidget.prototype._getRtlOption = function() { + var data_rtl; + if (this.options.rtl !== null) { + return this.options.rtl; + } else { + data_rtl = this.element.data('rtl'); + if ((data_rtl != null) && data_rtl !== false) { + return true; + } else { + return false; + } + } + }; + + JqTreeWidget.prototype._notifyLoading = function(is_loading, node, $el) { + if (this.options.onLoading) { + return this.options.onLoading(is_loading, node, $el); + } + }; + + return JqTreeWidget; + +})(MouseWidget); + +JqTreeWidget.getModule = function(name) { + var modules; + modules = { + 'node': node_module, + 'util': util_module, + 'drag_and_drop_handler': drag_and_drop_handler + }; + return modules[name]; +}; + +SimpleWidget.register(JqTreeWidget, 'tree'); + +},{"./drag_and_drop_handler":1,"./elements_renderer":2,"./key_handler":3,"./mouse.widget":4,"./node":5,"./node_element":6,"./save_state_handler":7,"./scroll_handler":8,"./select_node_handler":9,"./simple.widget":10,"./util":12,"./version":13}],12:[function(require,module,exports){ +var _indexOf, getBoolString, html_escape, indexOf, isFunction, isInt; + +_indexOf = function(array, item) { + var i, j, len, value; + for (i = j = 0, len = array.length; j < len; i = ++j) { + value = array[i]; + if (value === item) { + return i; + } + } + return -1; +}; + +indexOf = function(array, item) { + if (array.indexOf) { + return array.indexOf(item); + } else { + return _indexOf(array, item); + } +}; + +isInt = function(n) { + return typeof n === 'number' && n % 1 === 0; +}; + +isFunction = function(v) { + return typeof v === 'function'; +}; + +html_escape = function(string) { + return ('' + string).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g, '/'); +}; + +getBoolString = function(value) { + if (value) { + return 'true'; + } else { + return 'false'; + } +}; + +module.exports = { + _indexOf: _indexOf, + getBoolString: getBoolString, + html_escape: html_escape, + indexOf: indexOf, + isInt: isInt, + isFunction: isFunction +}; + +},{}],13:[function(require,module,exports){ +module.exports = '1.3.7'; + +},{}]},{},[11]); |