kit_cms 2.3.6

data/app/assets/javascripts/kit/application.js

@@ -0,0 +1,393 @@
+$(document).ready(function() {
+	
+	$('input[data-default], textarea[data-default]').focus(function(){
+		if($(this).val() == $(this).attr('data-default')) {
+	        $(this).val('');
+	        $(this).removeClass('field-hint');
+		}
+	});
+	
+	$('input[data-default], textarea[data-default]').blur(function(){
+		if($(this).val() == '' && $(this).attr('data-default') != ''){
+		    $(this).val($(this).attr('data-default'));
+  	        $(this).addClass('field-hint');
+		 }	
+	});
+	
+	
+	$('input[data-default], textarea[data-default]').each(function(){
+
+	    if($(this).val() == '') { 
+			$(this).val($(this).attr('data-default'));
+			$(this).addClass('field-hint'); 
+		}
+	    else { 
+			$(this).removeClass('field-hint'); 
+		}
+	});
+	
+
+	$('input[data-focus=auto]').focus();
+	
+});
+
+/*!
+ * JavaScript Debug - v0.4 - 6/22/2010
+ * http://benalman.com/projects/javascript-debug-console-log/
+ * 
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ * 
+ * With lots of help from Paul Irish!
+ * http://paulirish.com/
+ */
+
+// Script: JavaScript Debug: A simple wrapper for console.log
+//
+// *Version: 0.4, Last Updated: 6/22/2010*
+// 
+// Tested with Internet Explorer 6-8, Firefox 3-3.6, Safari 3-4, Chrome 3-5, Opera 9.6-10.5
+// 
+// Home       - http://benalman.com/projects/javascript-debug-console-log/
+// GitHub     - http://github.com/cowboy/javascript-debug/
+// Source     - http://github.com/cowboy/javascript-debug/raw/master/ba-debug.js
+// (Minified) - http://github.com/cowboy/javascript-debug/raw/master/ba-debug.min.js (1.1kb)
+// 
+// About: License
+// 
+// Copyright (c) 2010 "Cowboy" Ben Alman,
+// Dual licensed under the MIT and GPL licenses.
+// http://benalman.com/about/license/
+// 
+// About: Support and Testing
+// 
+// Information about what browsers this code has been tested in.
+// 
+// Browsers Tested - Internet Explorer 6-8, Firefox 3-3.6, Safari 3-4, Chrome
+// 3-5, Opera 9.6-10.5
+// 
+// About: Examples
+// 
+// These working examples, complete with fully commented code, illustrate a few
+// ways in which this plugin can be used.
+// 
+// Examples - http://benalman.com/code/projects/javascript-debug/examples/debug/
+// 
+// About: Revision History
+// 
+// 0.4 - (6/22/2010) Added missing passthrough methods: exception,
+//       groupCollapsed, table
+// 0.3 - (6/8/2009) Initial release
+// 
+// Topic: Pass-through console methods
+// 
+// assert, clear, count, dir, dirxml, exception, group, groupCollapsed,
+// groupEnd, profile, profileEnd, table, time, timeEnd, trace
+// 
+// These console methods are passed through (but only if both the console and
+// the method exists), so use them without fear of reprisal. Note that these
+// methods will not be passed through if the logging level is set to 0 via
+// <debug.setLevel>.
+
+window.debug = (function(){
+  var window = this,
+    
+    // Some convenient shortcuts.
+    aps = Array.prototype.slice,
+    con = window.console,
+    
+    // Public object to be returned.
+    that = {},
+    
+    callback_func,
+    callback_force,
+    
+    // Default logging level, show everything.
+    log_level = 9,
+    
+    // Logging methods, in "priority order". Not all console implementations
+    // will utilize these, but they will be used in the callback passed to
+    // setCallback.
+    log_methods = [ 'error', 'warn', 'info', 'debug', 'log' ],
+    
+    // Pass these methods through to the console if they exist, otherwise just
+    // fail gracefully. These methods are provided for convenience.
+    pass_methods = 'assert clear count dir dirxml exception group groupCollapsed groupEnd profile profileEnd table time timeEnd trace'.split(' '),
+    idx = pass_methods.length,
+    
+    // Logs are stored here so that they can be recalled as necessary.
+    logs = [];
+  
+  while ( --idx >= 0 ) {
+    (function( method ){
+      
+      // Generate pass-through methods. These methods will be called, if they
+      // exist, as long as the logging level is non-zero.
+      that[ method ] = function() {
+        log_level !== 0 && con && con[ method ]
+          && con[ method ].apply( con, arguments );
+      }
+      
+    })( pass_methods[idx] );
+  }
+  
+  idx = log_methods.length;
+  while ( --idx >= 0 ) {
+    (function( idx, level ){
+      
+      // Method: debug.log
+      // 
+      // Call the console.log method if available. Adds an entry into the logs
+      // array for a callback specified via <debug.setCallback>.
+      // 
+      // Usage:
+      // 
+      //  debug.log( object [, object, ...] );                               - -
+      // 
+      // Arguments:
+      // 
+      //  object - (Object) Any valid JavaScript object.
+      
+      // Method: debug.debug
+      // 
+      // Call the console.debug method if available, otherwise call console.log.
+      // Adds an entry into the logs array for a callback specified via
+      // <debug.setCallback>.
+      // 
+      // Usage:
+      // 
+      //  debug.debug( object [, object, ...] );                             - -
+      // 
+      // Arguments:
+      // 
+      //  object - (Object) Any valid JavaScript object.
+      
+      // Method: debug.info
+      // 
+      // Call the console.info method if available, otherwise call console.log.
+      // Adds an entry into the logs array for a callback specified via
+      // <debug.setCallback>.
+      // 
+      // Usage:
+      // 
+      //  debug.info( object [, object, ...] );                              - -
+      // 
+      // Arguments:
+      // 
+      //  object - (Object) Any valid JavaScript object.
+      
+      // Method: debug.warn
+      // 
+      // Call the console.warn method if available, otherwise call console.log.
+      // Adds an entry into the logs array for a callback specified via
+      // <debug.setCallback>.
+      // 
+      // Usage:
+      // 
+      //  debug.warn( object [, object, ...] );                              - -
+      // 
+      // Arguments:
+      // 
+      //  object - (Object) Any valid JavaScript object.
+      
+      // Method: debug.error
+      // 
+      // Call the console.error method if available, otherwise call console.log.
+      // Adds an entry into the logs array for a callback specified via
+      // <debug.setCallback>.
+      // 
+      // Usage:
+      // 
+      //  debug.error( object [, object, ...] );                             - -
+      // 
+      // Arguments:
+      // 
+      //  object - (Object) Any valid JavaScript object.
+      
+      that[ level ] = function() {
+        var args = aps.call( arguments ),
+          log_arr = [ level ].concat( args );
+        
+        logs.push( log_arr );
+        exec_callback( log_arr );
+        
+        if ( !con || !is_level( idx ) ) { return; }
+        
+        con.firebug ? con[ level ].apply( window, args )
+          : con[ level ] ? con[ level ]( args )
+          : con.log( args );
+      };
+      
+    })( idx, log_methods[idx] );
+  }
+  
+  // Execute the callback function if set.
+  function exec_callback( args ) {
+    if ( callback_func && (callback_force || !con || !con.log) ) {
+      callback_func.apply( window, args );
+    }
+  };
+  
+  // Method: debug.setLevel
+  // 
+  // Set a minimum or maximum logging level for the console. Doesn't affect
+  // the <debug.setCallback> callback function, but if set to 0 to disable
+  // logging, <Pass-through console methods> will be disabled as well.
+  // 
+  // Usage:
+  // 
+  //  debug.setLevel( [ level ] )                                            - -
+  // 
+  // Arguments:
+  // 
+  //  level - (Number) If 0, disables logging. If negative, shows N lowest
+  //    priority levels of log messages. If positive, shows N highest priority
+  //    levels of log messages.
+  //
+  // Priority levels:
+  // 
+  //   log (1) < debug (2) < info (3) < warn (4) < error (5)
+  
+  that.setLevel = function( level ) {
+    log_level = typeof level === 'number' ? level : 9;
+  };
+  
+  // Determine if the level is visible given the current log_level.
+  function is_level( level ) {
+    return log_level > 0
+      ? log_level > level
+      : log_methods.length + log_level <= level;
+  };
+  
+  // Method: debug.setCallback
+  // 
+  // Set a callback to be used if logging isn't possible due to console.log
+  // not existing. If unlogged logs exist when callback is set, they will all
+  // be logged immediately unless a limit is specified.
+  // 
+  // Usage:
+  // 
+  //  debug.setCallback( callback [, force ] [, limit ] )
+  // 
+  // Arguments:
+  // 
+  //  callback - (Function) The aforementioned callback function. The first
+  //    argument is the logging level, and all subsequent arguments are those
+  //    passed to the initial debug logging method.
+  //  force - (Boolean) If false, log to console.log if available, otherwise
+  //    callback. If true, log to both console.log and callback.
+  //  limit - (Number) If specified, number of lines to limit initial scrollback
+  //    to.
+  
+  that.setCallback = function() {
+    var args = aps.call( arguments ),
+      max = logs.length,
+      i = max;
+    
+    callback_func = args.shift() || null;
+    callback_force = typeof args[0] === 'boolean' ? args.shift() : false;
+    
+    i -= typeof args[0] === 'number' ? args.shift() : max;
+    
+    while ( i < max ) {
+      exec_callback( logs[i++] );
+    }
+  };
+  
+  return that;
+})();
+
+$(document).ajaxSend(function(e, xhr, options) {
+  var token = $("meta[name='csrf-token']").attr("content");
+  xhr.setRequestHeader("X-CSRF-Token", token);
+});
+
+$.extend({
+  getUrlVars: function(){
+    var vars = [], hash;
+    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
+    for(var i = 0; i < hashes.length; i++)
+    {
+      hash = hashes[i].split('=');
+      vars.push(hash[0]);
+      vars[hash[0]] = hash[1];
+    }
+    return vars;
+  },
+  getUrlVar: function(name){
+    return $.getUrlVars()[name];
+  }
+});
+
+$(document).ready(function() {
+
+  $('div#navbar div, div.home_hover').bind('mouseover', function() {
+    if ($(this).hasClass('home_hover'))  {
+      target = $('#home_link');
+    }
+    else {
+      target = $(this);
+    }
+      
+    if (!target.hasClass("hover")) {
+      $(target).addClass("hover");
+    }
+
+    $(target).find('a').addClass('hover');
+  });
+
+  $('div#navbar div, .home_hover').bind('mouseout', function() {
+    if ($(this).hasClass('home_hover'))  {
+      target = $('#home_link');
+    }
+    else {
+      target = $(this);
+    }
+      
+    target.removeClass("hover");
+    target.find('a').removeClass('hover');
+  });
+  
+  $('div#navbar div').bind('click', function() {
+    if ($(this).hasClass('home_hover'))  {
+      target = $('#home_link');
+    }
+    else {
+      target = $(this);
+    }
+    window.location = target.find('a').attr('href');
+  });
+});
+
+$.fn.extend({
+	outerHTML: function(htmlString)
+	{
+		if (htmlString) {
+			return this.replaceWith(htmlString);
+		}
+
+		if ('outerHTML' in this[0]) {
+			return this[0].outerHTML;
+		}
+
+		return (function(element) {
+			var attrs = element.attributes,
+			i = 0,
+			n = attrs ? attrs.length : 0,
+			name = element.nodeName ? element.nodeName.toLowerCase() : "",
+			attrlist = '';
+
+			for (; i != n; ++i) {
+				attrlist += ' ' + attrs[i].name + '="' + attrs[i].value + '"';
+			}
+			return '<' + name + attrlist + '>' + element.innerHTML + '</' + name + '>';
+		}(this[0]));
+	}
+});
+
+
+
+/********/
+
+

data/app/assets/javascripts/kit/best_in_place.js

@@ -0,0 +1,631 @@
+/*
+        BestInPlace (for jQuery)
+        version: 0.1.0 (01/01/2011)
+        @requires jQuery >= v1.4
+        @requires jQuery.purr to display pop-up windows
+
+        By Bernat Farrero based on the work of Jan Varwig.
+        Examples at http://bernatfarrero.com
+
+        Licensed under the MIT:
+          http://www.opensource.org/licenses/mit-license.php
+
+        Usage:
+
+        Attention.
+        The format of the JSON object given to the select inputs is the following:
+        [["key", "value"],["key", "value"]]
+        The format of the JSON object given to the checkbox inputs is the following:
+        ["falseValue", "trueValue"]
+*/
+
+function BestInPlaceEditor(e) {
+  this.element = jQuery(e);
+  this.initOptions();
+  this.bindForm();
+  this.initNil();
+  $(this.activator).bind('click', {editor: this}, this.clickHandler);
+}
+
+BestInPlaceEditor.prototype = {
+  // Public Interface Functions //////////////////////////////////////////////
+
+  activate : function() {
+    var to_display = "";
+    if (this.isNil) {
+      to_display = "";
+    }
+    else if (this.original_content) {
+      to_display = this.original_content;
+    }
+    else {
+      to_display = this.element.html();
+    }
+
+    var elem = this.isNil ? "" : this.element.html();
+    this.oldValue = elem;
+    this.display_value = to_display;
+    $(this.activator).unbind("click", this.clickHandler);
+    this.activateForm();
+  },
+
+  abort : function() {
+    if (this.isNil) this.element.html(this.nil);
+    else            this.element.html(this.oldValue);
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  abortIfConfirm : function () {
+    if (confirm("Are you sure you want to discard your changes?")) {
+      this.abort();
+    }
+  },
+
+  update : function() {
+    var editor = this;
+    if (this.formType in {"input":1, "textarea":1} && this.getValue() == this.oldValue)
+    { // Avoid request if no change is made
+      this.abort();
+      return true;
+    }
+    this.isNil = false;
+    editor.ajax({
+      "type"       : "post",
+      "dataType"   : "text",
+      "data"       : editor.requestData(),
+      "success"    : function(data){ editor.loadSuccessCallback(data); },
+      "error"      : function(request, error){ editor.loadErrorCallback(request, error); }
+    });
+    if (this.formType == "select") {
+      var value = this.getValue();
+      $.each(this.values, function(i, v) {
+        if (value == v[0]) {
+          editor.element.html(v[1]);
+        }
+      }
+    );
+    } else if (this.formType == "checkbox") {
+      editor.element.html(this.getValue() ? this.values[1] : this.values[0]);
+    } else {
+      editor.element.html(this.getValue() != "" ? this.getValue() : this.nil);
+    }
+    editor.element.trigger($.Event("best_in_place:update"));
+  },
+
+  activateForm : function() {
+    alert("The form was not properly initialized. activateForm is unbound");
+  },
+
+  // Helper Functions ////////////////////////////////////////////////////////
+
+  initOptions : function() {
+    // Try parent supplied info
+    var self = this;
+    self.element.parents().each(function(){
+      self.url           = self.url           || jQuery(this).attr("data-url");
+      self.collection    = self.collection    || jQuery(this).attr("data-collection");
+      self.formType      = self.formType      || jQuery(this).attr("data-type");
+      self.objectName    = self.objectName    || jQuery(this).attr("data-object");
+      self.attributeName = self.attributeName || jQuery(this).attr("data-attribute");
+      self.activator     = self.activator     || jQuery(this).attr("data-activator");
+      self.okButton      = self.okButton      || jQuery(this).attr("data-ok-button");
+      self.cancelButton  = self.cancelButton  || jQuery(this).attr("data-cancel-button");
+      self.nil           = self.nil           || jQuery(this).attr("data-nil");
+      self.inner_class   = self.inner_class   || jQuery(this).attr("data-inner-class");
+      self.html_attrs    = self.html_attrs    || jQuery(this).attr("data-html-attrs");
+      self.original_content    = self.original_content    || jQuery(this).attr("data-original-content");
+    });
+
+    // Try Rails-id based if parents did not explicitly supply something
+    self.element.parents().each(function(){
+      var res = this.id.match(/^(\w+)_(\d+)$/i);
+      if (res) {
+        self.objectName = self.objectName || res[1];
+      }
+    });
+
+    // Load own attributes (overrides all others)
+    self.url           = self.element.attr("data-url")           || self.url      || document.location.pathname;
+    self.collection    = self.element.attr("data-collection")    || self.collection;
+    self.formType      = self.element.attr("data-type")          || self.formtype || "input";
+    self.objectName    = self.element.attr("data-object")        || self.objectName;
+    self.attributeName = self.element.attr("data-attribute")     || self.attributeName;
+    self.activator     = self.element.attr("data-activator")     || self.element;
+    self.okButton      = self.element.attr("data-ok-button")     || self.okButton;
+    self.cancelButton  = self.element.attr("data-cancel-button") || self.cancelButton;
+    self.nil           = self.element.attr("data-nil")           || self.nil      || "-";
+    self.inner_class   = self.element.attr("data-inner-class")   || self.inner_class   || null;
+    self.html_attrs    = self.element.attr("data-html-attrs")    || self.html_attrs;
+    self.original_content    = self.element.attr("data-original-content") || self.original_content;
+
+    if (!self.element.attr("data-sanitize")) {
+      self.sanitize = true;
+    }
+    else {
+      self.sanitize = (self.element.attr("data-sanitize") == "true");
+    }
+
+    if ((self.formType == "select" || self.formType == "checkbox") && self.collection !== null)
+    {
+      self.values = jQuery.parseJSON(self.collection);
+    }
+  },
+
+  bindForm : function() {
+    this.activateForm = BestInPlaceEditor.forms[this.formType].activateForm;
+    this.getValue     = BestInPlaceEditor.forms[this.formType].getValue;
+  },
+
+  initNil: function() {
+    if (this.element.html() == "")
+    {
+      this.isNil = true
+      this.element.html(this.nil)
+    }
+  },
+
+  getValue : function() {
+    alert("The form was not properly initialized. getValue is unbound");
+  },
+
+  // Trim and Strips HTML from text
+  sanitizeValue : function(s) {
+    if (this.sanitize)
+    {
+      var tmp = document.createElement("DIV");
+      tmp.innerHTML = s;
+      s = tmp.textContent || tmp.innerText;
+    }
+   return jQuery.trim(s).replace(/"/g, '"');
+  },
+
+  /* Generate the data sent in the POST request */
+  requestData : function() {
+    // To prevent xss attacks, a csrf token must be defined as a meta attribute
+    csrf_token = $('meta[name=csrf-token]').attr('content');
+    csrf_param = $('meta[name=csrf-param]').attr('content');
+
+    var data = "_method=put";
+    data += "&" + this.objectName + '[' + this.attributeName + ']=' + encodeURIComponent(this.getValue());
+
+    if (csrf_param !== undefined && csrf_token !== undefined) {
+      data += "&" + csrf_param + "=" + encodeURIComponent(csrf_token);
+    }
+    return data;
+  },
+
+  ajax : function(options) {
+    options.url = this.url;
+    options.beforeSend = function(xhr){ xhr.setRequestHeader("Accept", "application/json"); };
+    return jQuery.ajax(options);
+  },
+
+  // Handlers ////////////////////////////////////////////////////////////////
+
+  loadSuccessCallback : function(data) {
+    var response = $.parseJSON($.trim(data));
+    if (response != null && response.hasOwnProperty("display_as")) {
+      this.element.attr("data-original-content", this.element.html());
+      this.original_content = this.element.html();
+      this.element.html(response["display_as"]);
+    }
+    this.element.trigger($.Event("ajax:success"), data);
+
+    // Binding back after being clicked
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  loadErrorCallback : function(request, error) {
+    this.element.html(this.oldValue);
+
+    // Display all error messages from server side validation
+    $.each(jQuery.parseJSON(request.responseText), function(index, value) {
+      if( typeof(value) == "object") {value = index + " " + value.toString(); }
+      var container = $("<span class='flash-error'></span>").html(value);
+      container.purr();
+    });
+
+    // Binding back after being clicked
+    $(this.activator).bind('click', {editor: this}, this.clickHandler);
+  },
+
+  clickHandler : function(event) {
+    event.data.editor.activate();
+  },
+
+  setHtmlAttributes : function() {
+    var formField = this.element.find(this.formType);
+    var attrs = jQuery.parseJSON(this.html_attrs);
+    for(var key in attrs){
+      formField.attr(key, attrs[key]);
+    }
+  }
+};
+
+
+// Button cases:
+// If no buttons, then blur saves, ESC cancels
+// If just Cancel button, then blur saves, ESC or clicking Cancel cancels (careful of blur event!)
+// If just OK button, then clicking OK saves (careful of blur event!), ESC or blur cancels
+// If both buttons, then clicking OK saves, ESC or clicking Cancel or blur cancels
+BestInPlaceEditor.forms = {
+  "input" : {
+    activateForm : function() {
+      var output = '<form class="form_in_place" action="javascript:void(0)" style="display:inline;">';
+      output += '<input type="text" name="'+ this.attributeName + '" value="' + this.sanitizeValue(this.display_value) + '"';
+      if (this.inner_class != null) {
+        output += ' class="' + this.inner_class + '"';
+      }
+      output += '>';
+      if (this.okButton) {
+        output += '<input type="submit" value="' + this.okButton + '" />'
+      }
+      if (this.cancelButton) {
+        output += '<input type="button" value="' + this.cancelButton + '" />'
+      }
+      output += '</form>';
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.element.find("input[type='text']")[0].select();
+      this.element.find("form").bind('submit', {editor: this}, BestInPlaceEditor.forms.input.submitHandler);
+      if (this.cancelButton) {
+        this.element.find("input[type='button']").bind('click', {editor: this}, BestInPlaceEditor.forms.input.cancelButtonHandler)
+      }
+      this.element.find("input[type='text']").bind('blur', {editor: this}, BestInPlaceEditor.forms.input.inputBlurHandler);
+      this.element.find("input[type='text']").bind('keyup', {editor: this}, BestInPlaceEditor.forms.input.keyupHandler);
+      this.blurTimer = null;
+      this.userClicked = false;
+    },
+
+    getValue : function() {
+      return this.sanitizeValue(this.element.find("input").val());
+    },
+
+    // When buttons are present, use a timer on the blur event to give precedence to clicks
+    inputBlurHandler : function(event) {
+      if (event.data.editor.okButton) {
+        event.data.editor.blurTimer = setTimeout(function () {
+          if (!event.data.editor.userClicked) {
+            event.data.editor.abort();
+          }
+        }, 500);
+      } else {
+        if (event.data.editor.cancelButton) {
+          event.data.editor.blurTimer = setTimeout(function () {
+            if (!event.data.editor.userClicked) {
+              event.data.editor.update();
+            }
+          }, 500);
+        } else {
+          event.data.editor.update();
+        }
+      }
+    },
+
+    submitHandler : function(event) {
+      event.data.editor.userClicked = true;
+      clearTimeout(event.data.editor.blurTimer);
+      event.data.editor.update();
+    },
+
+    cancelButtonHandler : function(event) {
+      event.data.editor.userClicked = true;
+      clearTimeout(event.data.editor.blurTimer);
+      event.data.editor.abort();
+      event.stopPropagation(); // Without this, click isn't handled
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) {
+        event.data.editor.abort();
+      }
+    }
+  },
+
+  "date" : {
+    activateForm : function() {
+      var that = this,
+        output = '<form class="form_in_place" action="javascript:void(0)" style="display:inline;">';
+      output += '<input type="text" name="'+ this.attributeName + '" value="' + this.sanitizeValue(this.display_value) + '"';
+      if (this.inner_class != null) {
+        output += ' class="' + this.inner_class + '"';
+      }
+      output += '></form>'
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.element.find('input')[0].select();
+      this.element.find("form").bind('submit', {editor: this}, BestInPlaceEditor.forms.input.submitHandler);
+      this.element.find("input").bind('keyup', {editor: this}, BestInPlaceEditor.forms.input.keyupHandler);
+
+      this.element.find('input')
+        .datepicker({
+            onClose: function() {
+              that.update();
+            }
+          })
+        .datepicker('show');
+    },
+
+    getValue :  function() {
+      return this.sanitizeValue(this.element.find("input").val());
+    },
+
+    submitHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) {
+        event.data.editor.abort();
+      }
+    }
+  },
+
+  "select" : {
+    activateForm : function() {
+      var output = "<form action='javascript:void(0)' style='display:inline;'><select>";
+      var selected = "";
+      var oldValue = this.oldValue;
+      $.each(this.values, function(index, value) {
+        selected = (value[1] == oldValue ? "selected='selected'" : "");
+        output += "<option value='" + value[0] + "' " + selected + ">" + value[1] + "</option>";
+       });
+      output += "</select></form>";
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.element.find("select").bind('change', {editor: this}, BestInPlaceEditor.forms.select.blurHandler);
+      this.element.find("select").bind('blur', {editor: this}, BestInPlaceEditor.forms.select.blurHandler);
+      this.element.find("select").bind('keyup', {editor: this}, BestInPlaceEditor.forms.select.keyupHandler);
+      this.element.find("select")[0].focus();
+    },
+
+    getValue : function() {
+      return this.sanitizeValue(this.element.find("select").val());
+    },
+
+    blurHandler : function(event) {
+      event.data.editor.update();
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) event.data.editor.abort();
+    }
+  },
+
+  "checkbox" : {
+    activateForm : function() {
+      var newValue = Boolean(this.oldValue != this.values[1]);
+      var output = newValue ? this.values[1] : this.values[0];
+      this.element.html(output);
+      this.setHtmlAttributes();
+      this.update();
+    },
+
+    getValue : function() {
+      return Boolean(this.element.html() == this.values[1]);
+    }
+  },
+
+  "textarea" : {
+    activateForm : function() {
+      // grab width and height of text
+      width = this.element.css('width');
+      height = this.element.css('height');
+
+      // construct the form
+      var output = '<form action="javascript:void(0)" style="display:inline;"><textarea>';
+      output += this.sanitizeValue(this.display_value);
+      output += '</textarea>';
+      if (this.okButton) {
+        output += '<input type="submit" value="' + this.okButton + '" />'
+      }
+      if (this.cancelButton) {
+        output += '<input type="button" value="' + this.cancelButton + '" />'
+      }
+      output += '</form>';
+      this.element.html(output);
+      this.setHtmlAttributes();
+
+      // set width and height of textarea
+      jQuery(this.element.find("textarea")[0]).css({ 'min-width': width, 'min-height': height });
+      jQuery(this.element.find("textarea")[0]).elastic();
+
+      this.element.find("textarea")[0].focus();
+      this.element.find("form").bind('submit', {editor: this}, BestInPlaceEditor.forms.textarea.submitHandler);
+      if (this.cancelButton) {
+        this.element.find("input[type='button']").bind('click', {editor: this}, BestInPlaceEditor.forms.textarea.cancelButtonHandler)
+      }
+      this.element.find("textarea").bind('blur', {editor: this}, BestInPlaceEditor.forms.textarea.blurHandler);
+      this.element.find("textarea").bind('keyup', {editor: this}, BestInPlaceEditor.forms.textarea.keyupHandler);
+      this.blurTimer = null;
+      this.userClicked = false;
+    },
+
+    getValue :  function() {
+      return this.sanitizeValue(this.element.find("textarea").val());
+    },
+
+    // When buttons are present, use a timer on the blur event to give precedence to clicks
+    blurHandler : function(event) {
+      if (event.data.editor.okButton) {
+        event.data.editor.blurTimer = setTimeout(function () {
+          if (!event.data.editor.userClicked) {
+            event.data.editor.abortIfConfirm();
+          }
+        }, 500);
+      } else {
+        if (event.data.editor.cancelButton) {
+          event.data.editor.blurTimer = setTimeout(function () {
+            if (!event.data.editor.userClicked) {
+              event.data.editor.update();
+            }
+          }, 500);
+        } else {
+          event.data.editor.update();
+        }
+      }
+    },
+
+    submitHandler : function(event) {
+      event.data.editor.userClicked = true;
+      clearTimeout(event.data.editor.blurTimer);
+      event.data.editor.update();
+    },
+
+    cancelButtonHandler : function(event) {
+      event.data.editor.userClicked = true;
+      clearTimeout(event.data.editor.blurTimer);
+      event.data.editor.abortIfConfirm();
+      event.stopPropagation(); // Without this, click isn't handled
+    },
+
+    keyupHandler : function(event) {
+      if (event.keyCode == 27) {
+        event.data.editor.abortIfConfirm();
+      }
+    }
+  }
+};
+
+jQuery.fn.best_in_place = function() {
+  this.each(function(){
+    if (!jQuery(this).data('bestInPlaceEditor')) {
+      jQuery(this).data('bestInPlaceEditor', new BestInPlaceEditor(this));
+    }
+  });
+  return this;
+};
+
+
+
+/**
+* @name             Elastic
+* @descripton           Elastic is Jquery plugin that grow and shrink your textareas automaticliy
+* @version            1.6.5
+* @requires           Jquery 1.2.6+
+*
+* @author             Jan Jarfalk
+* @author-email         jan.jarfalk@unwrongest.com
+* @author-website         http://www.unwrongest.com
+*
+* @licens             MIT License - http://www.opensource.org/licenses/mit-license.php
+*/
+
+(function(jQuery){
+  jQuery.fn.extend({
+    elastic: function() {
+      //  We will create a div clone of the textarea
+      //  by copying these attributes from the textarea to the div.
+      var mimics = [
+        'paddingTop',
+        'paddingRight',
+        'paddingBottom',
+        'paddingLeft',
+        'fontSize',
+        'lineHeight',
+        'fontFamily',
+        'width',
+        'fontWeight'];
+
+      return this.each( function() {
+
+        // Elastic only works on textareas
+        if ( this.type != 'textarea' ) {
+          return false;
+        }
+
+        var $textarea = jQuery(this),
+          $twin   = jQuery('<div />').css({'position': 'absolute','display':'none','word-wrap':'break-word'}),
+          lineHeight  = parseInt($textarea.css('line-height'),10) || parseInt($textarea.css('font-size'),'10'),
+          minheight = parseInt($textarea.css('height'),10) || lineHeight*3,
+          maxheight = parseInt($textarea.css('max-height'),10) || Number.MAX_VALUE,
+          goalheight  = 0,
+          i       = 0;
+
+        // Opera returns max-height of -1 if not set
+        if (maxheight < 0) { maxheight = Number.MAX_VALUE; }
+
+        // Append the twin to the DOM
+        // We are going to meassure the height of this, not the textarea.
+        $twin.appendTo($textarea.parent());
+
+        // Copy the essential styles (mimics) from the textarea to the twin
+        var i = mimics.length;
+        while(i--){
+          $twin.css(mimics[i].toString(),$textarea.css(mimics[i].toString()));
+        }
+
+
+        // Sets a given height and overflow state on the textarea
+        function setHeightAndOverflow(height, overflow){
+          curratedHeight = Math.floor(parseInt(height,10));
+          if($textarea.height() != curratedHeight){
+            $textarea.css({'height': curratedHeight + 'px','overflow':overflow});
+
+          }
+        }
+
+
+        // This function will update the height of the textarea if necessary
+        function update() {
+
+          // Get curated content from the textarea.
+          var textareaContent = $textarea.val().replace(/&/g,'&amp;').replace(/  /g, '&nbsp;').replace(/<|>/g, '&gt;').replace(/\n/g, '<br />');
+
+          // Compare curated content with curated twin.
+          var twinContent = $twin.html().replace(/<br>/ig,'<br />');
+
+          if(textareaContent+'&nbsp;' != twinContent){
+
+            // Add an extra white space so new rows are added when you are at the end of a row.
+            $twin.html(textareaContent+'&nbsp;');
+
+            // Change textarea height if twin plus the height of one line differs more than 3 pixel from textarea height
+            if(Math.abs($twin.height() + lineHeight - $textarea.height()) > 3){
+
+              var goalheight = $twin.height()+lineHeight;
+              if(goalheight >= maxheight) {
+                setHeightAndOverflow(maxheight,'auto');
+              } else if(goalheight <= minheight) {
+                setHeightAndOverflow(minheight,'hidden');
+              } else {
+                setHeightAndOverflow(goalheight,'hidden');
+              }
+
+            }
+
+          }
+
+        }
+
+        // Hide scrollbars
+        $textarea.css({'overflow':'hidden'});
+
+        // Update textarea size on keyup, change, cut and paste
+        $textarea.bind('keyup change cut paste', function(){
+          update();
+        });
+
+        // Compact textarea on blur
+        // Lets animate this....
+        $textarea.bind('blur',function(){
+          if($twin.height() < maxheight){
+            if($twin.height() > minheight) {
+              $textarea.height($twin.height());
+            } else {
+              $textarea.height(minheight);
+            }
+          }
+        });
+
+        // And this line is to catch the browser paste event
+        $textarea.live('input paste',function(e){ setTimeout( update, 250); });
+
+        // Run update once when elastic is initialized
+        update();
+
+      });
+
+        }
+    });
+})(jQuery);