| /* |
| JqTree 1.3.2 |
| |
| 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, |
| 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'); |
| |
| 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 offset; |
| this.refresh(); |
| offset = $(position_info.target).offset(); |
| this.drag_element = new DragElement(this.current_item.node, 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'); |
| }; |
| |
| 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, 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}],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); |
| this.attachNodeData(node, li); |
| $previous_li.after(li); |
| $previous_li.remove(); |
| if (node.children) { |
| return this.createDomElements(li, node.children, false, false, node.getLevel()); |
| } |
| }; |
| |
| 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) { |
| 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 { |
| 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) { |
| var result; |
| result = null; |
| this.iterate(function(node) { |
| if (node.name === name) { |
| 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); |
| 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); |
| 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); |
| return node; |
| }; |
| |
| Node.prototype.prepend = function(node_info) { |
| var node; |
| node = new this.tree.node_class(node_info); |
| this.addChildAtPosition(node, 0); |
| 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(); |
| } |
| 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, error1, 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; |
| this._initScrollParent(); |
| } |
| |
| 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.id) { |
| return this.selected_nodes[node.id]; |
| } 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__, node_module, ref, ref1, 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'); |
| |
| ref = require('./drag_and_drop_handler'), DragAndDropHandler = ref.DragAndDropHandler, DragElement = ref.DragElement, HitAreasGenerator = ref.HitAreasGenerator; |
| |
| 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'); |
| |
| ref1 = require('./node_element'), BorderDropHint = ref1.BorderDropHint, FolderElement = ref1.FolderElement, GhostDropHint = ref1.GhostDropHint, NodeElement = ref1.NodeElement; |
| |
| $ = 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.openNode = function(node, slide) { |
| if (slide == null) { |
| slide = null; |
| } |
| if (slide === null) { |
| slide = this.options.slide; |
| } |
| this._openNode(node, slide); |
| 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); |
| } |
| 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() { |
| if (this.options.data) { |
| return this._loadData(this.options.data); |
| } else { |
| return this._loadDataFromUrl(this._getDataUrlInfo()); |
| } |
| }; |
| |
| 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, ref2, 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); |
| ref2 = restoreState(), is_restored = ref2[0], must_load_on_demand = ref2[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 |
| }; |
| 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, 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; |
| }; |
| |
| 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 |
| }; |
| |
| },{}],13:[function(require,module,exports){ |
| module.exports = '1.3.2'; |
| |
| },{}]},{},[11]); |