jqtree-rails 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg/
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    inflection-js-rails (0.1.0)
+      railties (>= 3.2.0, < 5.0)
+      thor (~> 0.14)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.0.0)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    json (1.6.6)
+    multi_json (1.2.0)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    railties (3.2.3)
+      actionpack (= 3.2.3)
+      activesupport (= 3.2.3)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  inflection-js-rails!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Andre Arko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# jqtree-rails
+
+Adds [jqTree](https://github.com/mbraak/jqTree) to the Rails 3 asset pipeline.
+
+## Installation
+
+In your Gemfile, add this line:
+
+```ruby
+gem :assets do
+  gem 'jqtree-rails'
+end
+```
+
+Now run `bundle install`.
+
+### Rails 3.0
+
+This gem adds a single generator to Rails 3, `jqtree:install`.
+
+Running the generator will copy over the assets to your assets to your public directory.
+
+### Rails 3.1 or greater
+
+For Rails 3.1 and greater, the files will be added to the asset pipeline and available for you to use.
+
+Simply the following to `app/assets/javascripts/application.js`:
+
+    //= require tree.jquery
+
+And the following to `app/assets/stylesheets/application.css`:
+
+    /*
+     * require jqtree
+     */
+
+## saveState
+
+To enable `saveState`, simply follow the installation instructions for [http://github.com/c00lryguy/jquery-cookie-rails](jquery-cookie-rails).
+
+jqTree will detect `jquery.cookie.js` and will enable `saveState`.
+
+## Props
+
+I didn't write any of the Javascript included within jqTree.  
+All props goto [mbraak](https://github.com/mbraak).
+
+## Contributing
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Ryan Lewis. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# require "spec/rake/spectask"
+# desc "Run all examples"
+# Spec::Rake::SpecTask.new(:spec) do |t|
+#   t.ruby_opts  = ['-r test/unit']
+#   t.spec_opts = %w[--color]
+# end
+task :default => :spec

data/jqtree-rails.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/jqtree/rails/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = File.basename(__FILE__, '.gemspec')
+  s.version     = JqTree::Rails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ryan Scott Lewis"]
+  s.email       = ["c00lryguy@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/#{s.name}"
+  s.summary     = "Use jqTree with Rails 3"
+  s.description = "This gem provides jqTree assets for your Rails 3 application."
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_dependency "railties", ">= 3.2.0", "< 5.0"
+  s.add_dependency "thor",     "~> 0.14"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_path = 'lib'
+end

data/lib/generators/jqtree/install/install_generator.rb

@@ -0,0 +1,40 @@
+require 'rails'
+
+# Supply generator for Rails 3.0.x or if asset pipeline is not enabled
+if ::Rails.version < "3.1" || !::Rails.application.config.assets.enabled
+  module JqTree
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+
+        desc "This generator installs jqtree #{JqTree::Rails::JQTREE_VERSION}"
+        source_root File.expand_path('../../../../../vendor/assets', __FILE__)
+
+        def copy_jqtree
+          say_status("copying", "jqtree (#{JqTree::Rails::JQTREE_VERSION})", :green)
+          copy_file "javascripts/tree.jquery.js", "public/javascripts/tree.jquery.js"
+          copy_file "stylesheets/jqtree.css", "public/javascripts/jqtree.css"
+          copy_file "images/treeDownTriangleBlack.png", "public/images/treeDownTriangleBlack.png"
+          copy_file "images/treeRightTriangleBlack.png", "public/images/treeRightTriangleBlack.png"
+        end
+
+      end
+    end
+  end
+else
+  module JqTree
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        desc "Just show instructions so people will know what to do when mistakenly using generator for Rails 3.1 apps"
+
+        def do_nothing
+          say_status("deprecated", "You are using Rails 3.1 or the asset pipeline enabled, so this generator is not needed.")
+          say_status("", "The necessary files are already in your asset pipeline.")
+          say_status("", "Just add `//= require tree.jquery` to your app/assets/javascripts/application.js")
+          say_status("", "and add `/* require jqtree */` to your app/assets/stylesheets/application.css")
+          say_status("", "If you do not want the asset pipeline enabled, you may turn it off in application.rb and re-run this generator.")
+          # ok, nothing
+        end
+      end
+    end
+  end
+end

data/lib/jqtree-rails.rb

@@ -0,0 +1 @@
+require 'jqtree/rails'

data/lib/jqtree/rails.rb

@@ -0,0 +1,2 @@
+require 'jqtree/rails/engine'
+require 'jqtree/rails/version'

data/lib/jqtree/rails/engine.rb

@@ -0,0 +1,6 @@
+module JqTree
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/jqtree/rails/version.rb

@@ -0,0 +1,6 @@
+module JqTree
+  module Rails
+    VERSION = "0.1.0"
+    JQTREE_VERSION = "0.7"
+  end
+end

data/vendor/assets/javascripts/tree.jquery.js

@@ -0,0 +1,1551 @@
+// 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, JqueryWidget, 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;
+    };
+
+    return SimpleWidget;
+
+  })();
+
+  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);
+        }
+      }
+    };
+  };
+
+  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];
+    if (value && typeof value === 'object' && typeof value.toJSON === 'function') {
+      value = value.toJSON(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) {
+        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, _results;
+        _results = [];
+        for (_i = 0, _len = children_data.length; _i < _len; _i++) {
+          child = children_data[_i];
+          node = new Node();
+          node.initFromData(child);
+          _results.push(_this.addChild(node));
+        }
+        return _results;
+      };
+      return addNode(data);
+    };
+
+    /*
+        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, _results,
+        _this = this;
+      this.children = [];
+      _results = [];
+      for (_i = 0, _len = data.length; _i < _len; _i++) {
+        o = data[_i];
+        node = new Node(o.label);
+        $.each(o, function(key, value) {
+          if (key !== 'label') {
+            node[key] = value;
+          }
+          return true;
+        });
+        this.addChild(node);
+        if (o.children) {
+          _results.push(node.loadFromData(o.children));
+        } else {
+          _results.push(void 0);
+        }
+      }
+      return _results;
+    };
+
+    /*
+        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, _results;
+        _ref = _this.children;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          child = _ref[_i];
+          result = callback(child, level);
+          if (_this.hasChildren() && result) {
+            _results.push(child.iterate(callback, level + 1));
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      };
+      return _iterate(0);
+    };
+
+    /*
+        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;
+
+  JqueryWidget = (function(_super) {
+
+    __extends(JqueryWidget, _super);
+
+    JqueryWidget.name = 'JqueryWidget';
+
+    function JqueryWidget() {
+      return JqueryWidget.__super__.constructor.apply(this, arguments);
+    }
+
+    JqueryWidget.prototype.defaults = {
+      autoOpen: false,
+      saveState: false,
+      dragAndDrop: false,
+      selectable: false,
+      onCanSelectNode: null,
+      onSetStateFromStorage: null,
+      onGetStateFromStorage: null,
+      onCreateLi: null,
+      onIsMoveHandle: null,
+      onCanMove: null,
+      onCanMoveTo: null
+    };
+
+    JqueryWidget.prototype.toggle = function(node, on_finished) {
+      if (node.hasChildren()) {
+        new FolderElement(node).toggle(on_finished);
+      }
+      if (this.options.saveState) {
+        return this._saveState();
+      }
+    };
+
+    JqueryWidget.prototype.getTree = function() {
+      return this.tree;
+    };
+
+    JqueryWidget.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();
+        }
+      }
+    };
+
+    JqueryWidget.prototype.getSelectedNode = function() {
+      return this.selected_node || false;
+    };
+
+    JqueryWidget.prototype.toJson = function() {
+      return toJson(this.tree.getData());
+    };
+
+    JqueryWidget.prototype.loadData = function(data, parent_node) {
+      var $div, $element, child, subtree, _i, _len, _ref;
+      if (!parent_node) {
+        return 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) {
+          return $div.prepend('<a class="toggler">&raquo;</a>');
+        }
+      }
+    };
+
+    JqueryWidget.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;
+    };
+
+    JqueryWidget.prototype.openNode = function(node, on_finished, skip_slide) {
+      if (node.hasChildren()) {
+        return new FolderElement(node).open(on_finished, skip_slide);
+      }
+    };
+
+    JqueryWidget.prototype._init = function() {
+      JqueryWidget.__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;
+      return this.hit_areas = [];
+    };
+
+    JqueryWidget.prototype._deinit = function() {
+      this.element.empty();
+      this.element.unbind();
+      this.tree = null;
+      return JqueryWidget.__super__._deinit.apply(this, arguments);
+    };
+
+    JqueryWidget.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();
+        }
+      }
+    };
+
+    JqueryWidget.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;
+      });
+    };
+
+    JqueryWidget.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, _results;
+        $ul = createUl(depth, is_open);
+        $element.append($ul);
+        _results = [];
+        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()) {
+            _results.push(doCreateDomElements($li, child.children, depth + 1, child.is_open));
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      };
+      if ($element) {
+        depth = 1;
+      } else {
+        $element = this.element;
+        $element.empty();
+        depth = 0;
+      }
+      return doCreateDomElements($element, tree.children, depth, true);
+    };
+
+    JqueryWidget.prototype._click = function(e) {
+      var $target, event, node, node_element,
+        _this = this;
+      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(function() {
+            var event, event_name, node;
+            node = node_element.node;
+            if (node.is_open) {
+              event_name = 'tree.open';
+            } else {
+              event_name = 'tree.close';
+            }
+            event = $.Event(event_name);
+            event.node = node;
+            return _this.element.trigger(event);
+          });
+          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);
+          }
+        }
+      }
+    };
+
+    JqueryWidget.prototype._getNode = function($element) {
+      var $li;
+      $li = $element.closest('li');
+      if ($li.length === 0) {
+        return null;
+      } else {
+        return $li.data('node');
+      }
+    };
+
+    JqueryWidget.prototype._restoreState = function() {
+      var state;
+      if (this.options.onGetStateFromStorage) {
+        state = this.options.onGetStateFromStorage();
+      } else {
+        if ($.cookie) {
+          state = $.cookie(this._getCookieName(), {
+            path: '/'
+          });
+        } else {
+          state = null;
+        }
+      }
+      if (!state) {
+        return false;
+      } else {
+        this._setState(state);
+        return true;
+      }
+    };
+
+    JqueryWidget.prototype._saveState = function() {
+      if (this.options.onSetStateFromStorage) {
+        return this.options.onSetStateFromStorage(this._getState());
+      } else {
+        if ($.cookie) {
+          return $.cookie(this._getCookieName(), this._getState(), {
+            path: '/'
+          });
+        }
+      }
+    };
+
+    JqueryWidget.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
+      });
+    };
+
+    JqueryWidget.prototype._setState = function(state) {
+      var data, open_nodes, selected_node_id,
+        _this = this;
+      data = $.parseJSON(state);
+      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;
+      });
+    };
+
+    JqueryWidget.prototype._getCookieName = function() {
+      if (typeof this.options.saveState === 'string') {
+        return this.options.saveState;
+      } else {
+        return 'tree';
+      }
+    };
+
+    JqueryWidget.prototype._getNodeElementForNode = function(node) {
+      if (node.hasChildren()) {
+        return new FolderElement(node);
+      } else {
+        return new NodeElement(node);
+      }
+    };
+
+    JqueryWidget.prototype._getNodeElement = function($element) {
+      var node;
+      node = this._getNode($element);
+      if (node) {
+        return this._getNodeElementForNode(node);
+      } else {
+        return null;
+      }
+    };
+
+    JqueryWidget.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;
+        }
+      }
+    };
+
+    JqueryWidget.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;
+    };
+
+    JqueryWidget.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.current_item.$element.addClass('moving');
+      return true;
+    };
+
+    JqueryWidget.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;
+    };
+
+    JqueryWidget.prototype._mouseStop = function() {
+      if (!this.options.dragAndDrop) {
+        return;
+      }
+      this._moveItem();
+      this._clear();
+      this._removeHover();
+      this._removeDropHint();
+      this._removeHitAreas();
+      this.current_item.$element.removeClass('moving');
+      return false;
+    };
+
+    JqueryWidget.prototype._refreshHitAreas = function() {
+      this._removeHitAreas();
+      return this._generateHitAreas();
+    };
+
+    JqueryWidget.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, _results;
+        area_height = (bottom - top) / positions_in_group.length;
+        area_top = top;
+        _results = [];
+        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
+          });
+          _results.push(area_top += area_height);
+        }
+        return _results;
+      });
+      return this.hit_areas = hit_areas;
+    };
+
+    JqueryWidget.prototype._removeHitAreas = function() {
+      return this.hit_areas = [];
+    };
+
+    JqueryWidget.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);
+    };
+
+    JqueryWidget.prototype._getOffsetFromEvent = function(event) {
+      var element_offset;
+      element_offset = $(event.target).offset();
+      return [event.pageX - element_offset.left, event.pageY - element_offset.top];
+    };
+
+    JqueryWidget.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;
+    };
+
+    JqueryWidget.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);
+    };
+
+    JqueryWidget.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);
+    };
+
+    JqueryWidget.prototype._stopOpenFolderTimer = function() {
+      if (this.open_folder_timer) {
+        clearTimeout(this.open_folder_timer);
+        return this.open_folder_timer = null;
+      }
+    };
+
+    JqueryWidget.prototype._removeDropHint = function() {
+      if (this.previous_ghost) {
+        return this.previous_ghost.remove();
+      }
+    };
+
+    JqueryWidget.prototype._removeHover = function() {
+      return this.hovered_area = null;
+    };
+
+    JqueryWidget.prototype._moveItem = function() {
+      var event, moved_node, position, previous_parent, target_node;
+      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;
+        this.tree.moveNode(moved_node, target_node, position);
+        if (position === Position.INSIDE) {
+          this.hovered_area.node.is_open = true;
+        }
+        event = $.Event('tree.move');
+        event.move_info = {
+          moved_node: moved_node,
+          target_node: target_node,
+          position: Position.getName(position),
+          previous_parent: previous_parent
+        };
+        this.element.trigger(event);
+        this.element.empty();
+        return this._createDomElements(this.tree);
+      }
+    };
+
+    JqueryWidget.prototype._clear = function() {
+      this.drag_element.remove();
+      return this.drag_element = null;
+    };
+
+    return JqueryWidget;
+
+  })(MouseWidget);
+
+  SimpleWidget.register(JqueryWidget, '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) {
+      this.init(node);
+    }
+
+    NodeElement.prototype.init = function(node) {
+      this.node = node;
+      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() {
+        _this.getLi().removeClass('closed');
+        if (on_finished) {
+          return on_finished();
+        }
+      };
+      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() {
+        _this.getLi().addClass('closed');
+        if (on_finished) {
+          return on_finished();
+        }
+      });
+    };
+
+    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);