tree.jquery.js

// Generated by CoffeeScript 1.3.1

/*
Copyright 2012 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() {
  var $, BorderDropHint, DragElement, FolderElement, GhostDropHint, JqTreeWidget, Json, MouseWidget, Node, NodeElement, Position, SimpleWidget, indexOf, toJson,
    __slice = [].slice,
    __hasProp = {}.hasOwnProperty,
    __extends = 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; };

  $ = this.jQuery;

  SimpleWidget = (function() {

    SimpleWidget.name = 'SimpleWidget';

    SimpleWidget.prototype.defaults = {};

    function SimpleWidget(el, options) {
      this.$el = $(el);
      this.options = $.extend({}, this.defaults, options);
      this._init();
    }

    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;
      getDataKey = function() {
        return "simple_widget_" + widget_name;
      };
      createWidget = function($el, options) {
        var data_key;
        data_key = getDataKey();
        $el.each(function() {
          var widget;
          widget = new widget_class(this, options);
          if (!$.data(this, data_key)) {
            return $.data(this, data_key, widget);
          }
        });
        return $el;
      };
      destroyWidget = function($el) {
        var data_key;
        data_key = getDataKey();
        return $el.each(function() {
          var widget;
          widget = $.data(this, data_key);
          if (widget && (widget instanceof SimpleWidget)) {
            widget.destroy();
          }
          return $.removeData(this, data_key);
        });
      };
      callFunction = function($el, function_name, args) {
        var result;
        result = null;
        $el.each(function() {
          var widget, widget_function;
          widget = $.data(this, getDataKey());
          if (widget && (widget instanceof SimpleWidget)) {
            widget_function = widget[function_name];
            if (widget_function && (typeof widget_function === 'function')) {
              return 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 {
            return callFunction($el, function_name, args);
          }
        }
      };
    };

    return SimpleWidget;

  })();

  this.SimpleWidget = SimpleWidget;

  /*
  This widget does the same a the mouse widget in jqueryui.
  */


  MouseWidget = (function(_super) {

    __extends(MouseWidget, _super);

    MouseWidget.name = 'MouseWidget';

    function MouseWidget() {
      return MouseWidget.__super__.constructor.apply(this, arguments);
    }

    MouseWidget.is_mouse_handled = false;

    MouseWidget.prototype._init = function() {
      this.$el.bind('mousedown', $.proxy(this._mouseDown, this));
      return this.is_mouse_started = false;
    };

    MouseWidget.prototype._deinit = function() {
      var $document;
      this.$el.unbind('mousedown');
      $document = $(document);
      $document.unbind('mousemove');
      return $document.unbind('mouseup');
    };

    MouseWidget.prototype._mouseDown = function(e) {
      var $document;
      if (MouseWidget.is_mouse_handled) {
        return;
      }
      if (!this.is_mouse_started) {
        this._mouseUp(e);
      }
      if (e.which !== 1) {
        return;
      }
      if (!this._mouseCapture(e)) {
        return;
      }
      this.mouse_down_event = e;
      $document = $(document);
      $document.bind('mousemove', $.proxy(this._mouseMove, this));
      $document.bind('mouseup', $.proxy(this._mouseUp, this));
      e.preventDefault();
      this.is_mouse_handled = true;
      return true;
    };

    MouseWidget.prototype._mouseMove = function(e) {
      if (this.is_mouse_started) {
        this._mouseDrag(e);
        return e.preventDefault();
      }
      this.is_mouse_started = this._mouseStart(this.mouse_down_event) !== false;
      if (this.is_mouse_started) {
        this._mouseDrag(e);
      } else {
        this._mouseUp(e);
      }
      return !this.is_mouse_started;
    };

    MouseWidget.prototype._mouseUp = function(e) {
      var $document;
      $document = $(document);
      $document.unbind('mousemove');
      $document.unbind('mouseup');
      if (this.is_mouse_started) {
        this.is_mouse_started = false;
        this._mouseStop(e);
      }
      return false;
    };

    MouseWidget.prototype._mouseCapture = function(e) {
      return true;
    };

    MouseWidget.prototype._mouseStart = function(e) {
      return null;
    };

    MouseWidget.prototype._mouseDrag = function(e) {
      return null;
    };

    MouseWidget.prototype._mouseStop = function(e) {
      return null;
    };

    return MouseWidget;

  })(SimpleWidget);

  /*
  Copyright 2012 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.
  */


  this.Tree = {};

  $ = this.jQuery;

  indexOf = function(array, item) {
    var i, value, _i, _len;
    if (array.indexOf) {
      return array.indexOf(item);
    } else {
      for (i = _i = 0, _len = array.length; _i < _len; i = ++_i) {
        value = array[i];
        if (value === item) {
          return i;
        }
      }
      return -1;
    }
  };

  this.Tree.indexOf = indexOf;

  Json = {};

  Json.escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;

  Json.meta = {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '"': '\\"',
    '\\': '\\\\'
  };

  Json.quote = function(string) {
    Json.escapable.lastIndex = 0;
    if (Json.escapable.test(string)) {
      return '"' + string.replace(Json.escapable, function(a) {
        var c;
        c = Json.meta[a];
        return (typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4));
      }) + '"';
    } else {
      return '"' + string + '"';
    }
  };

  Json.str = function(key, holder) {
    var i, k, partial, v, value, _i, _len;
    value = holder[key];
    switch (typeof value) {
      case 'string':
        return Json.quote(value);
      case 'number':
        if (isFinite(value)) {
          return String(value);
        } else {
          return 'null';
        }
      case 'boolean':
      case 'null':
        return String(value);
      case 'object':
        if (!value) {
          return 'null';
        }
        partial = [];
        if (Object.prototype.toString.apply(value) === '[object Array]') {
          for (i = _i = 0, _len = value.length; _i < _len; i = ++_i) {
            v = value[i];
            partial[i] = Json.str(i, value) || 'null';
          }
          return (partial.length === 0 ? '[]' : '[' + partial.join(',') + ']');
        }
        for (k in value) {
          if (Object.prototype.hasOwnProperty.call(value, k)) {
            v = Json.str(k, value);
            if (v) {
              partial.push(Json.quote(k) + ':' + v);
            }
          }
        }
        return (partial.length === 0 ? '{}' : '{' + partial.join(',') + '}');
    }
  };

  toJson = function(value) {
    return Json.str('', {
      '': value
    });
  };

  this.Tree.toJson = toJson;

  Position = {
    getName: function(position) {
      if (position === Position.BEFORE) {
        return 'before';
      } else if (position === Position.AFTER) {
        return 'after';
      } else if (position === Position.INSIDE) {
        return 'inside';
      } else {
        return 'none';
      }
    }
  };

  Position.BEFORE = 1;

  Position.AFTER = 2;

  Position.INSIDE = 3;

  Position.NONE = 4;

  this.Tree.Position = Position;

  Node = (function() {

    Node.name = 'Node';

    function Node(name) {
      this.init(name);
    }

    Node.prototype.init = function(name) {
      this.name = name;
      this.children = [];
      return this.parent = null;
    };

    Node.prototype.initFromData = function(data) {
      var addChildren, addNode,
        _this = this;
      addNode = function(node_data) {
        if (typeof node_data !== 'object') {
          return _this['name'] = node_data;
        } else {
          return $.each(node_data, function(key, value) {
            if (key === 'children') {
              addChildren(value);
            } else if (key === 'label') {
              _this['name'] = value;
            } else {
              _this[key] = value;
            }
            return true;
          });
        }
      };
      addChildren = function(children_data) {
        var child, node, _i, _len;
        for (_i = 0, _len = children_data.length; _i < _len; _i++) {
          child = children_data[_i];
          node = new Node();
          node.initFromData(child);
          _this.addChild(node);
        }
        return null;
      };
      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 node, o, _i, _len,
        _this = this;
      this.children = [];
      for (_i = 0, _len = data.length; _i < _len; _i++) {
        o = data[_i];
        if (typeof o !== 'object') {
          node = new Node(o);
          this.addChild(node);
        } else {
          node = new Node(o.label);
          $.each(o, function(key, value) {
            if (key !== 'label') {
              node[key] = value;
            }
            return true;
          });
          this.addChild(node);
          if (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.parent = 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.parent = this;
    };

    /*
        Remove child.
    
        tree.removeChile(tree.children[0]);
    */


    Node.prototype.removeChild = function(node) {
      return this.children.splice(this.getChildIndex(node), 1);
    };

    /*
        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;
    };

    /*
        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,
        _this = this;
      _iterate = function(level) {
        var child, result, _i, _len, _ref;
        _ref = _this.children;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          child = _ref[_i];
          result = callback(child, level);
          if (_this.hasChildren() && result) {
            child.iterate(callback, level + 1);
          }
        }
        return null;
      };
      _iterate(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) {
      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() {
      var getDataFromNodes,
        _this = this;
      getDataFromNodes = function(nodes) {
        var data, k, node, tmp_node, v, _i, _len;
        data = [];
        for (_i = 0, _len = nodes.length; _i < _len; _i++) {
          node = nodes[_i];
          tmp_node = {};
          for (k in node) {
            v = node[k];
            if ((k !== 'parent' && k !== 'children' && k !== 'element') && 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;
      };
      return getDataFromNodes(this.children);
    };

    return Node;

  })();

  this.Tree.Tree = Node;

  JqTreeWidget = (function(_super) {

    __extends(JqTreeWidget, _super);

    JqTreeWidget.name = 'JqTreeWidget';

    function JqTreeWidget() {
      return JqTreeWidget.__super__.constructor.apply(this, arguments);
    }

    JqTreeWidget.prototype.defaults = {
      autoOpen: false,
      saveState: false,
      dragAndDrop: false,
      selectable: false,
      onCanSelectNode: null,
      onSetStateFromStorage: null,
      onGetStateFromStorage: null,
      onCreateLi: null,
      onIsMoveHandle: null,
      onCanMove: null,
      onCanMoveTo: null
    };

    JqTreeWidget.prototype.toggle = function(node, on_finished) {
      if (node.hasChildren()) {
        new FolderElement(node, this.element).toggle(on_finished);
      }
      if (this.options.saveState) {
        return this._saveState();
      }
    };

    JqTreeWidget.prototype.getTree = function() {
      return this.tree;
    };

    JqTreeWidget.prototype.selectNode = function(node, must_open_parents) {
      var parent;
      if (this.options.selectable) {
        if (this.selected_node) {
          this._getNodeElementForNode(this.selected_node).deselect();
        }
        this._getNodeElementForNode(node).select();
        this.selected_node = node;
        if (must_open_parents) {
          parent = this.selected_node.parent;
          while (parent) {
            if (!parent.is_open) {
              this.openNode(parent, null, true);
            }
            parent = parent.parent;
          }
        }
        if (this.options.saveState) {
          return this._saveState();
        }
      }
    };

    JqTreeWidget.prototype.getSelectedNode = function() {
      return this.selected_node || false;
    };

    JqTreeWidget.prototype.toJson = function() {
      return toJson(this.tree.getData());
    };

    JqTreeWidget.prototype.loadData = function(data, parent_node) {
      var $div, $element, child, subtree, _i, _len, _ref;
      if (!parent_node) {
        this._initTree(data);
      } else {
        subtree = new Node();
        subtree.loadFromData(data);
        _ref = subtree.children;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          child = _ref[_i];
          parent_node.addChild(child);
        }
        $element = $(parent_node.element);
        $element.children('ul').detach();
        this._createDomElements(parent_node, $element);
        $div = $element.children('div');
        if (!$div.find('.toggler').length) {
          $div.prepend('<a class="toggler">&raquo;</a>');
        }
      }
      if (this.is_dragging) {
        return this._refreshHitAreas();
      }
    };

    JqTreeWidget.prototype.getNodeById = function(node_id) {
      var result;
      result = null;
      this.tree.iterate(function(node) {
        if (node.id === node_id) {
          result = node;
          return false;
        } else {
          return true;
        }
      });
      return result;
    };

    JqTreeWidget.prototype.openNode = function(node, on_finished, skip_slide) {
      if (node.hasChildren()) {
        return new FolderElement(node, this.element).open(on_finished, skip_slide);
      }
    };

    JqTreeWidget.prototype.isDragging = function() {
      return this.is_dragging;
    };

    JqTreeWidget.prototype.refreshHitAreas = function() {
      return this._refreshHitAreas();
    };

    JqTreeWidget.prototype._init = function() {
      JqTreeWidget.__super__._init.apply(this, arguments);
      this.element = this.$el;
      this._initTree(this.options.data);
      this.element.click($.proxy(this._click, this));
      this.element.bind('contextmenu', $.proxy(this._contextmenu, this));
      this.hovered_area = null;
      this.$ghost = null;
      this.hit_areas = [];
      return this.is_dragging = false;
    };

    JqTreeWidget.prototype._deinit = function() {
      this.element.empty();
      this.element.unbind();
      this.tree = null;
      return JqTreeWidget.__super__._deinit.apply(this, arguments);
    };

    JqTreeWidget.prototype._initTree = function(data) {
      var node_element;
      this.tree = new Node();
      this.tree.loadFromData(data);
      this.selected_node = null;
      this._openNodes();
      this._createDomElements(this.tree);
      if (this.selected_node) {
        node_element = this._getNodeElementForNode(this.selected_node);
        if (node_element) {
          return node_element.select();
        }
      }
    };

    JqTreeWidget.prototype._openNodes = function() {
      var max_level;
      if (this.options.saveState) {
        if (this._restoreState()) {
          return;
        }
      }
      if (this.options.autoOpen === false) {
        return;
      } else if (this.options.autoOpen === true) {
        max_level = -1;
      } else {
        max_level = parseInt(this.options.autoOpen);
      }
      return this.tree.iterate(function(node, level) {
        node.is_open = true;
        return level !== max_level;
      });
    };

    JqTreeWidget.prototype._createDomElements = function(tree, $element) {
      var createFolderLi, createLi, createNodeLi, createUl, depth, doCreateDomElements,
        _this = this;
      createUl = function(depth, is_open) {
        var class_string;
        if (depth) {
          class_string = '';
        } else {
          class_string = ' class="tree"';
        }
        return $("<ul" + class_string + "></ul>");
      };
      createLi = function(node) {
        var $li;
        if (node.hasChildren()) {
          $li = createFolderLi(node);
        } else {
          $li = createNodeLi(node);
        }
        if (_this.options.onCreateLi) {
          _this.options.onCreateLi(node, $li);
        }
        return $li;
      };
      createNodeLi = function(node) {
        return $("<li><div><span class=\"title\">" + node.name + "</span></div></li>");
      };
      createFolderLi = function(node) {
        var button_class, folder_class, getButtonClass, getFolderClass;
        getButtonClass = function() {
          var classes;
          classes = ['toggler'];
          if (!node.is_open) {
            classes.push('closed');
          }
          return classes.join(' ');
        };
        getFolderClass = function() {
          var classes;
          classes = ['folder'];
          if (!node.is_open) {
            classes.push('closed');
          }
          return classes.join(' ');
        };
        button_class = getButtonClass();
        folder_class = getFolderClass();
        return $("<li class=\"" + folder_class + "\"><div><a class=\"" + button_class + "\">&raquo;</a><span class=\"title\">" + node.name + "</span></div></li>");
      };
      doCreateDomElements = function($element, children, depth, is_open) {
        var $li, $ul, child, _i, _len;
        $ul = createUl(depth, is_open);
        $element.append($ul);
        for (_i = 0, _len = children.length; _i < _len; _i++) {
          child = children[_i];
          $li = createLi(child);
          $ul.append($li);
          child.element = $li[0];
          $li.data('node', child);
          if (child.hasChildren()) {
            doCreateDomElements($li, child.children, depth + 1, child.is_open);
          }
        }
        return null;
      };
      if ($element) {
        depth = 1;
      } else {
        $element = this.element;
        $element.empty();
        depth = 0;
      }
      return doCreateDomElements($element, tree.children, depth, true);
    };

    JqTreeWidget.prototype._click = function(e) {
      var $target, event, node, node_element;
      if (e.ctrlKey) {
        return;
      }
      $target = $(e.target);
      if ($target.is('.toggler')) {
        node_element = this._getNodeElement($target);
        if (node_element && node_element.node.hasChildren()) {
          node_element.toggle();
          if (this.options.saveState) {
            this._saveState();
          }
          e.preventDefault();
          return e.stopPropagation();
        }
      } else if ($target.is('div') || $target.is('span')) {
        node = this._getNode($target);
        if (node) {
          if ((!this.options.onCanSelectNode) || this.options.onCanSelectNode(node)) {
            this.selectNode(node);
            event = $.Event('tree.click');
            event.node = node;
            return this.element.trigger(event);
          }
        }
      }
    };

    JqTreeWidget.prototype._getNode = function($element) {
      var $li;
      $li = $element.closest('li');
      if ($li.length === 0) {
        return null;
      } else {
        return $li.data('node');
      }
    };

    JqTreeWidget.prototype._restoreState = function() {
      var state;
      if (this.options.onGetStateFromStorage) {
        state = this.options.onGetStateFromStorage();
      } else if (localStorage) {
        state = localStorage.getItem(this._getCookieName());
      } else if ($.cookie) {
        state = $.cookie(this._getCookieName(), {
          path: '/'
        });
      } else {
        state = null;
      }
      if (!state) {
        return false;
      } else {
        this._setState(state);
        return true;
      }
    };

    JqTreeWidget.prototype._saveState = function() {
      if (this.options.onSetStateFromStorage) {
        return this.options.onSetStateFromStorage(this._getState());
      } else if (localStorage) {
        return localStorage.setItem(this._getCookieName(), this._getState());
      } else if ($.cookie) {
        return $.cookie(this._getCookieName(), this._getState(), {
          path: '/'
        });
      }
    };

    JqTreeWidget.prototype._getState = function() {
      var open_nodes, selected_node,
        _this = this;
      open_nodes = [];
      this.tree.iterate(function(node) {
        if (node.is_open && node.id && node.hasChildren()) {
          open_nodes.push(node.id);
        }
        return true;
      });
      selected_node = '';
      if (this.selected_node) {
        selected_node = this.selected_node.id;
      }
      return toJson({
        open_nodes: open_nodes,
        selected_node: selected_node
      });
    };

    JqTreeWidget.prototype._setState = function(state) {
      var data, open_nodes, selected_node_id,
        _this = this;
      data = $.parseJSON(state);
      if (data) {
        open_nodes = data.open_nodes;
        selected_node_id = data.selected_node;
        return this.tree.iterate(function(node) {
          if (node.id && node.hasChildren() && (indexOf(open_nodes, node.id) >= 0)) {
            node.is_open = true;
          }
          if (selected_node_id && (node.id === selected_node_id)) {
            _this.selected_node = node;
          }
          return true;
        });
      }
    };

    JqTreeWidget.prototype._getCookieName = function() {
      if (typeof this.options.saveState === 'string') {
        return this.options.saveState;
      } else {
        return 'tree';
      }
    };

    JqTreeWidget.prototype._getNodeElementForNode = function(node) {
      if (node.hasChildren()) {
        return new FolderElement(node, this.element);
      } else {
        return new NodeElement(node, this.element);
      }
    };

    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, event, node;
      $div = $(e.target).closest('ul.tree div');
      if ($div.length) {
        node = this._getNode($div);
        if (node) {
          e.preventDefault();
          e.stopPropagation();
          event = $.Event('tree.contextmenu');
          event.node = node;
          event.click_event = e;
          this.element.trigger(event);
          return false;
        }
      }
    };

    JqTreeWidget.prototype._mouseCapture = function(event) {
      var $element, node_element;
      if (!this.options.dragAndDrop) {
        return;
      }
      $element = $(event.target);
      if (this.options.onIsMoveHandle && !this.options.onIsMoveHandle($element)) {
        return null;
      }
      node_element = this._getNodeElement($(event.target));
      if (node_element && this.options.onCanMove) {
        if (!this.options.onCanMove(node_element.node)) {
          node_element = null;
        }
      }
      this.current_item = node_element;
      return this.current_item !== null;
    };

    JqTreeWidget.prototype._mouseStart = function(event) {
      var offsetX, offsetY, _ref;
      if (!this.options.dragAndDrop) {
        return;
      }
      this._refreshHitAreas();
      _ref = this._getOffsetFromEvent(event), offsetX = _ref[0], offsetY = _ref[1];
      this.drag_element = new DragElement(this.current_item.node, offsetX, offsetY, this.element);
      this.is_dragging = true;
      this.current_item.$element.addClass('moving');
      return true;
    };

    JqTreeWidget.prototype._mouseDrag = function(event) {
      var area, position_name;
      if (!this.options.dragAndDrop) {
        return;
      }
      this.drag_element.move(event.pageX, event.pageY);
      area = this._findHoveredArea(event.pageX, event.pageY);
      if (area && this.options.onCanMoveTo) {
        position_name = Position.getName(area.position);
        if (!this.options.onCanMoveTo(this.current_item.node, area.node, position_name)) {
          area = null;
        }
      }
      if (!area) {
        this._removeDropHint();
        this._removeHover();
        this._stopOpenFolderTimer();
      } else {
        if (this.hovered_area !== area) {
          this.hovered_area = area;
          this._updateDropHint();
        }
      }
      return true;
    };

    JqTreeWidget.prototype._mouseStop = function() {
      if (!this.options.dragAndDrop) {
        return;
      }
      this._moveItem();
      this._clear();
      this._removeHover();
      this._removeDropHint();
      this._removeHitAreas();
      this.current_item.$element.removeClass('moving');
      this.is_dragging = false;
      return false;
    };

    JqTreeWidget.prototype._refreshHitAreas = function() {
      this._removeHitAreas();
      return this._generateHitAreas();
    };

    JqTreeWidget.prototype._generateHitAreas = function() {
      var addPosition, getTop, groupPositions, handleAfterOpenFolder, handleClosedFolder, handleFirstNode, handleNode, handleOpenFolder, hit_areas, last_top, positions,
        _this = this;
      positions = [];
      last_top = 0;
      getTop = function($element) {
        return $element.offset().top;
      };
      addPosition = function(node, position, top) {
        positions.push({
          top: top,
          node: node,
          position: position
        });
        return last_top = top;
      };
      groupPositions = function(handle_group) {
        var group, position, previous_top, _i, _len;
        previous_top = -1;
        group = [];
        for (_i = 0, _len = positions.length; _i < _len; _i++) {
          position = positions[_i];
          if (position.top !== previous_top) {
            if (group.length) {
              handle_group(group, previous_top, position.top);
            }
            previous_top = position.top;
            group = [];
          }
          group.push(position);
        }
        return handle_group(group, previous_top, _this.element.offset().top + _this.element.height());
      };
      handleNode = function(node, next_node, $element) {
        var top;
        top = getTop($element);
        if (node === _this.current_item.node) {
          addPosition(node, Position.NONE, top);
        } else {
          addPosition(node, Position.INSIDE, top);
        }
        if (next_node === _this.current_item.node || node === _this.current_item.node) {
          return addPosition(node, Position.NONE, top);
        } else {
          return addPosition(node, Position.AFTER, top);
        }
      };
      handleOpenFolder = function(node, $element) {
        if (node === _this.current_item.node) {
          return false;
        }
        if (node.children[0] !== _this.current_item.node) {
          addPosition(node, Position.INSIDE, getTop($element));
        }
        return true;
      };
      handleAfterOpenFolder = function(node, next_node, $element) {
        if (node === _this.current_item.node || next_node === _this.current_item.node) {
          return addPosition(node, Position.NONE, last_top);
        } else {
          return addPosition(node, Position.AFTER, last_top);
        }
      };
      handleClosedFolder = function(node, next_node, $element) {
        var top;
        top = getTop($element);
        if (node === _this.current_item.node) {
          return addPosition(node, Position.NONE, top);
        } else {
          addPosition(node, Position.INSIDE, top);
          if (next_node !== _this.current_item.node) {
            return addPosition(node, Position.AFTER, top);
          }
        }
      };
      handleFirstNode = function(node, $element) {
        if (node !== _this.current_item.node) {
          return addPosition(node, Position.BEFORE, getTop($(node.element)));
        }
      };
      this._iterateVisibleNodes(handleNode, handleOpenFolder, handleClosedFolder, handleAfterOpenFolder, handleFirstNode);
      hit_areas = [];
      groupPositions(function(positions_in_group, top, bottom) {
        var area_height, area_top, position, _i, _len;
        area_height = (bottom - top) / positions_in_group.length;
        area_top = top;
        for (_i = 0, _len = positions_in_group.length; _i < _len; _i++) {
          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;
        }
        return null;
      });
      return this.hit_areas = hit_areas;
    };

    JqTreeWidget.prototype.testGenerateHitAreas = function(moving_node) {
      this.current_item = this._getNodeElementForNode(moving_node);
      this._generateHitAreas();
      return this.hit_areas;
    };

    JqTreeWidget.prototype._removeHitAreas = function() {
      return this.hit_areas = [];
    };

    JqTreeWidget.prototype._iterateVisibleNodes = function(handle_node, handle_open_folder, handle_closed_folder, handle_after_open_folder, handle_first_node) {
      var is_first_node, iterate,
        _this = this;
      is_first_node = true;
      iterate = function(node, next_node) {
        var $element, child, children_length, i, must_iterate_inside, _i, _len, _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) {
            handle_first_node(node, $element);
            is_first_node = false;
          }
          if (!node.hasChildren()) {
            handle_node(node, next_node, $element);
          } else if (node.is_open) {
            if (!handle_open_folder(node, $element)) {
              must_iterate_inside = false;
            }
          } else {
            handle_closed_folder(node, next_node, $element);
          }
        }
        if (must_iterate_inside) {
          children_length = node.children.length;
          _ref = node.children;
          for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
            child = _ref[i];
            if (i === (children_length - 1)) {
              iterate(node.children[i], null);
            } else {
              iterate(node.children[i], node.children[i + 1]);
            }
          }
          if (node.is_open) {
            return handle_after_open_folder(node, next_node, $element);
          }
        }
      };
      return iterate(this.tree);
    };

    JqTreeWidget.prototype._getOffsetFromEvent = function(event) {
      var element_offset;
      element_offset = $(event.target).offset();
      return [event.pageX - element_offset.left, event.pageY - element_offset.top];
    };

    JqTreeWidget.prototype._findHoveredArea = function(x, y) {
      var area, high, low, mid, tree_offset;
      tree_offset = this.element.offset();
      if (x < tree_offset.left || y < tree_offset.top || x > (tree_offset.left + this.element.width()) || y > (tree_offset.top + this.element.height())) {
        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;
    };

    JqTreeWidget.prototype._updateDropHint = function() {
      var node, node_element;
      this._stopOpenFolderTimer();
      if (!this.hovered_area) {
        return;
      }
      node = this.hovered_area.node;
      if (node.hasChildren() && !node.is_open && this.hovered_area.position === Position.INSIDE) {
        this._startOpenFolderTimer(node);
      }
      this._removeDropHint();
      node_element = this._getNodeElementForNode(this.hovered_area.node);
      return this.previous_ghost = node_element.addDropHint(this.hovered_area.position);
    };

    JqTreeWidget.prototype._startOpenFolderTimer = function(folder) {
      var openFolder,
        _this = this;
      openFolder = function() {
        return _this._getNodeElementForNode(folder).open(function() {
          _this._refreshHitAreas();
          return _this._updateDropHint();
        });
      };
      return this.open_folder_timer = setTimeout(openFolder, 500);
    };

    JqTreeWidget.prototype._stopOpenFolderTimer = function() {
      if (this.open_folder_timer) {
        clearTimeout(this.open_folder_timer);
        return this.open_folder_timer = null;
      }
    };

    JqTreeWidget.prototype._removeDropHint = function() {
      if (this.previous_ghost) {
        return this.previous_ghost.remove();
      }
    };

    JqTreeWidget.prototype._removeHover = function() {
      return this.hovered_area = null;
    };

    JqTreeWidget.prototype._moveItem = function() {
      var doMove, event, moved_node, position, previous_parent, target_node,
        _this = this;
      if (this.hovered_area && this.hovered_area.position !== Position.NONE) {
        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.tree.moveNode(moved_node, target_node, position);
          _this.element.empty();
          return _this._createDomElements(_this.tree);
        };
        event = $.Event('tree.move');
        event.move_info = {
          moved_node: moved_node,
          target_node: target_node,
          position: Position.getName(position),
          previous_parent: previous_parent,
          do_move: doMove
        };
        this.element.trigger(event);
        if (!event.isDefaultPrevented()) {
          return doMove();
        }
      }
    };

    JqTreeWidget.prototype._clear = function() {
      this.drag_element.remove();
      return this.drag_element = null;
    };

    return JqTreeWidget;

  })(MouseWidget);

  SimpleWidget.register(JqTreeWidget, 'tree');

  GhostDropHint = (function() {

    GhostDropHint.name = 'GhostDropHint';

    function GhostDropHint(node, $element, position) {
      this.$element = $element;
      this.node = node;
      this.$ghost = $('<li class="ghost"><span class="circle"></span><span class="line"></span></li>');
      if (position === Position.AFTER) {
        this.moveAfter();
      } else if (position === Position.BEFORE) {
        this.moveBefore();
      } else if (position === Position.INSIDE) {
        if (node.hasChildren() && 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('inside');
    };

    return GhostDropHint;

  })();

  BorderDropHint = (function() {

    BorderDropHint.name = 'BorderDropHint';

    function BorderDropHint($element) {
      var $div, width;
      $div = $element.children('div');
      width = $element.width() - 4;
      this.$hint = $('<span class="border"></span>');
      $div.append(this.$hint);
      this.$hint.css({
        width: width,
        height: $div.height() - 4
      });
    }

    BorderDropHint.prototype.remove = function() {
      return this.$hint.remove();
    };

    return BorderDropHint;

  })();

  NodeElement = (function() {

    NodeElement.name = 'NodeElement';

    function NodeElement(node, tree_element) {
      this.init(node, tree_element);
    }

    NodeElement.prototype.init = function(node, tree_element) {
      this.node = node;
      this.tree_element = tree_element;
      return this.$element = $(node.element);
    };

    NodeElement.prototype.getUl = function() {
      return this.$element.children('ul:first');
    };

    NodeElement.prototype.getSpan = function() {
      return this.$element.children('div').find('span.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() {
      return this.getLi().addClass('selected');
    };

    NodeElement.prototype.deselect = function() {
      return this.getLi().removeClass('selected');
    };

    return NodeElement;

  })();

  FolderElement = (function(_super) {

    __extends(FolderElement, _super);

    FolderElement.name = 'FolderElement';

    function FolderElement() {
      return FolderElement.__super__.constructor.apply(this, arguments);
    }

    FolderElement.prototype.toggle = function(on_finished) {
      if (this.node.is_open) {
        return this.close(on_finished);
      } else {
        return this.open(on_finished);
      }
    };

    FolderElement.prototype.open = function(on_finished, skip_slide) {
      var doOpen,
        _this = this;
      this.node.is_open = true;
      this.getButton().removeClass('closed');
      doOpen = function() {
        var event;
        _this.getLi().removeClass('closed');
        if (on_finished) {
          on_finished();
        }
        event = $.Event('tree.open');
        event.node = _this.node;
        return _this.tree_element.trigger(event);
      };
      if (skip_slide) {
        this.getUl().show();
        return doOpen();
      } else {
        return this.getUl().slideDown('fast', doOpen);
      }
    };

    FolderElement.prototype.close = function(on_finished) {
      var _this = this;
      this.node.is_open = false;
      this.getButton().addClass('closed');
      return this.getUl().slideUp('fast', function() {
        var event;
        _this.getLi().addClass('closed');
        if (on_finished) {
          on_finished();
        }
        event = $.Event('tree.close');
        event.node = _this.node;
        return _this.tree_element.trigger(event);
      });
    };

    FolderElement.prototype.getButton = function() {
      return this.$element.children('div').find('a.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);

  DragElement = (function() {

    DragElement.name = 'DragElement';

    function DragElement(node, offset_x, offset_y, $tree) {
      this.offset_x = offset_x;
      this.offset_y = offset_y;
      this.$element = $("<span class=\"title tree-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;

  })();

  this.Tree.Node = Node;

}).call(this);